Re: DDD correctly emulated by HHH is Correctly rejected as non-halting V2

Am Sat, 13 Jul 2024 06:39:31 -0500 schrieb olcott:

On 7/13/2024 3:15 AM, Fred. Zwarts wrote:

Op 13.jul.2024 om 01:19 schreef olcott:

On 7/12/2024 5:56 PM, Richard Damon wrote:

On 7/12/24 10:56 AM, olcott wrote:
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.

And thus HHH that do that know only the first N steps of the behavior
of DDD, which continues per the definition of the x86 instruction set
until the COMPLETE emulation (or direct execution) reaches a terminal
instruction.

And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning to
their caller, they establish that behavior for ALL copies of that
HHH, even the one that DDD calls, which shows that DDD will be
halting, even though HHH stopped its observation of the input before
it gets to that point.

This is the crux. You think that the nested HHH runs forever. But it
aborts just the same as the outer one.

Wrong. EVERY DDD of an HHH that simulated its input for only a finite
number of steps WILL halt becuase it will reach its final return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not reached
a "termial" instruction that stops behavior, will see the HHH(DDD)
that DDD called continuing to simulate its input to the point that
this one was defined to stop, and then returns 0 to DDDD and then DDD
returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the ACTUAL
FULL behavior of DDD as defined by the full definition of the x86
insttuction set.

Worth requoting.

NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around
to rejecting its DDD as non-halting.

>
When no DDD of every HHH/DDD that can possibly exist halts then each
HHH that rejects its DDD as non-halting is necessarily correct.
>

This is double talk, because no HHH can possibly exist that simulates
itself correctly.

Your definition of correct contradicts the semantics of the x86 language
making it wrong.

What part of it contradicts which semantics?
What are the doubletalk and weasel words?
What are the shells of the game?

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.