Re: DDD emulated by HHH diverges from DDD emulated by HHH1

Am Fri, 06 Jun 2025 14:18:26 -0500 schrieb olcott:

On 6/6/2025 2:14 PM, joes wrote:

Am Fri, 06 Jun 2025 12:35:40 -0500 schrieb olcott:

On 6/6/2025 12:26 PM, joes wrote:

Am Wed, 04 Jun 2025 21:15:52 -0500 schrieb olcott:

On 6/4/2025 8:48 PM, Richard Damon wrote:

On 6/4/25 10:52 AM, olcott wrote:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

>

The DDD emulated (correctly or otherwise) by HHH is the same
DDD as the one emulated (correctly or otherwise) so both
specify the same behaviour.

>
No they do not. When DDD calls its own emulator its behavior is
different than when DDD calls another different emulator.

 

Their code is the same and has the same meaning. DDD always calls
HHH.

You overlooked this.

Please cut the above if you read it.

If the input string does not unambiguously specify one and only
one behaviour it is incorrectly encoded and not a valid input
string. The halting problem of Truing machines requires that
every pair of a Turing macnine and input is descibed so that the
behaviour to be decided about is the only behaviour that meets to
the description.
>

The code proves what it proves.

>

So what "simulation" is the above? It seems that you are showing a
trace from x86, not what HHH is doing.
>

What I am showing is DDD emulated by HHH1 side-by-side with DDD
emulated by HHH
>
*They initially match up*
DDD emulated by HHH1              DDD emulated by HHH [00002183]
push ebp               [00002183] push ebp [00002184] mov ebp,esp
[00002184] mov ebp,esp [00002186] push 00002183 ; DDD    [00002186]
push 00002183 ; DDD [0000218b] call 000015c3 ; HHH    [0000218b]
call 000015c3 ; HHH *The matching is now all used up*
>
*Then DDD emulated by HHH does something*
*that DDD emulated by HHH1 never does*
*it emulates DDD all over again*

>
HHH1 also does that, and more, because it doesn't abort.
>

HHH emulates itself emulating DDD HHH1 NEVER emulates itself

I didn't say that it did. Like HHH it simulates HHH simulating DDD.
 

HHH1(DDD) simulates DDD that eventually halts. HHH(DDD) simulates DDD
that cannot possibly halt.

There is no "DDD that doesn't halt". *HHH* doesn't simulate it far enough.
Indeed no simulator can simulate itself further than it has executed. That
is just a feature of simulation and has nothing to do with the halting
problem.

You must pay actual attention to the actual execution traces. When you
simply assume what these traces should be you are stupidly wrong.

I don't need to assume. Your traces show it.

--
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.