Re: The actual truth is that ... Turing computability issues have been addressed --- marathon winner

Am Wed, 16 Oct 2024 07:52:00 -0500 schrieb olcott:

On 10/16/2024 1:32 AM, joes wrote:

Am Tue, 15 Oct 2024 22:52:00 -0500 schrieb olcott:

On 10/15/2024 9:11 PM, Richard Damon wrote:

On 10/15/24 8:39 AM, olcott wrote:

On 10/15/2024 4:58 AM, joes wrote:

Am Mon, 14 Oct 2024 20:12:37 -0500 schrieb olcott:

On 10/14/2024 6:50 PM, Richard Damon wrote:

On 10/14/24 12:05 PM, olcott wrote:

On 10/14/2024 6:21 AM, Richard Damon wrote:

On 10/14/24 5:53 AM, olcott wrote:

On 10/14/2024 3:21 AM, Mikko wrote:

On 2024-10-13 12:49:01 +0000, Richard Damon said:

On 10/12/24 8:11 PM, olcott wrote:

>

Trying to change to a different analytical framework than the
one that I am stipulating is the strawman deception.
*Essentially an intentional fallacy of equivocation error*

But, you claim to be working on that Halting Problem,

I quit claiming this many messages ago and you didn't bother to
notice.

Can you please give the date and time? Did you also explicitly
disclaim it or just silently leave it out?

Even people of low intelligence that are not trying to be as
disagreeable as possible would be able to notice that a specified C
function is not a Turing machine.

But it needs to be computationally equivalent to one to ask about
Termination.

Not at all. A termination analyzer need not be a Turing computable
function.

It definitely does. An uncomputable analyser is useless.

It is true that a termination analyzer is not required to work correctly
for all inputs.

But it should work for DDD.

That there is one way that HHH can consistently catch the
non-terminating pattern of its input proves that this can be done.

DDD does terminate. Otherwise it would contradict the HP.

Mike suggested some different ways that would seem to be Turing
computable yet too convoluted to be time consuming for me to implement
in practice.

What are those ways?

The basic approach involves the idea that every state change of the
emulations of emulations is data that belongs to the outermost directly
executed HHH.

Nothing special. They aren't even running on the hardware proper.

It is too convoluted for me to provide a way for HHH to look inside all
of the emulations of emulations and pull out the data that it needs, so
knowing that this is possible is enough to know that it is Turing
computable.

It cannot dig into an infinite simulation chain.

When HHH is an x86 emulation based termination analyzer then each DDD
*correctly_emulated_by* any HHH that it calls never returns.
Each of the directly executed HHH emulator/analyzers that returns 0
correctly reports the above *non_terminating _behavior* of its input.

If HHH doesn't return, DDD doesn't either, not even the directly
executed one.

When HHH is an x86 emulation based termination analyzer then each DDD
*correctly_emulated_by* any HHH that it calls never returns.

Only because the nested HHH doesn't abort.

Every nested HHH has seen one less execution trace than the next outer
one. The outermost one aborts its emulation as soon as it has seen
enough. Thus each inner HHH cannot possibly abort its own emulation.

Each inner HHH must abort if the outer does, since they are the same
program. Of course, the outer doesn't simulate the inner abort, because
it has already aborted. Therefore the outer HHH doesn't need to abort,
because the inner HHHs already halt by themselves. Reverse the if(Root)
check on line 500 or what in Halt7.c. As long as at least one of the
infinitely many HHHs aborts, the whole chain terminates (but the nested
HHHs don't get simulated completely). But they are all the same program,
so all of them must have the abort.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.