Re: 197 page execution trace of DDD correctly simulated by HHH

On 6/28/2024 12:41 PM, joes wrote:

Thanks for leaving the unanswered questions in place, though I’d rather
have you answer them.
 Am Fri, 28 Jun 2024 12:05:18 -0500 schrieb olcott:

On 6/28/2024 11:26 AM, joes wrote:

Am Fri, 28 Jun 2024 10:25:36 -0500 schrieb olcott:

On 6/28/2024 8:14 AM, joes wrote:

Am Thu, 27 Jun 2024 12:30:38 -0500 schrieb olcott:

 

To the caller DDD, which then returns to its own caller H0, which
returns „halting” to main… hold on.

Where do you disagree?

 

H0 must not report on itself, only on DDD. Which you’ve proven halts.
We don’t care how H0 deviates (i.e. is incorrect) in its simulation.
That would be main {H0(H0(DDD))}.

Do you see what I mean?
 

The behavior of the directly executed DDD() is irrelevant because that
is not the behavior of the input.

What is the difference here?

Isn’t the input DDD?
 

In this case the sequence is the line-by-line execution trace of the
behavior of DDD correctly emulated by HHH.

No, the sequence is the behaviour of DDD, period.

The input is not HHH(DDD). See above.
 

The behavior of this input must include and cannot ignore the
recursive emulation specified by the fact that DDD is calling its own
emulator.

Yes, and the behaviour of H0 is that it produces the exact same
behaviour as DDD.

Because it is a simulator.
 

The call from DDD to HHH(DDD) when N steps of DDD are correctly emulated
by any pure function x86 emulator HHH cannot possibly return.
That you assume that it does against the facts is ridiculous.

I don’t. A simulator doesn’t even need to return. That’s not in question.
A decider however must.

That you keep trying to ignore the fact that DDD calls HHH(DDD)
in recursive simulation is your huge mistake.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer