Path: news.eternal-september.org!eternal-september.org!feeder3.eternal-september.org!news.quux.org!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: The execution trace of HHH1(DDD) shows the divergence
Date: Sat, 7 Jun 2025 19:21:45 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <80a21b34a000ca7a0c794e211d8ac40ad345c3f6@i2pn2.org>
References: <1021ii4$3327l$6@dont-email.me>
 <ea4fed8afb01fbb7f3fd2e61e9310f4df06b3705.camel@gmail.com>
 <1021k02$3327l$8@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 7 Jun 2025 23:51:15 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="3748038"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <1021k02$3327l$8@dont-email.me>

On 6/7/25 10:57 AM, olcott wrote:
> On 6/7/2025 9:54 AM, wij wrote:
>> On Sat, 2025-06-07 at 09:32 -0500, olcott wrote:
>>> The execution trace of HHH1(DDD) shows the divergence
>>> of DDD emulated by HHH from DDD emulated by HHH1.
>>>
>>> int main()
>>> {
>>>     HHH1(DDD);
>>> }
>>>
>>> Shows that DDD emulated by HHH and DDD emulated by
>>> HHH1 diverges as soon as HHH begins emulating itself
>>> emulating DDD.
>>>
>>> *From the execution trace of HHH1(DDD) shown below*
>>> 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
>>> *HHH1 emulates DDD once then HHH emulates DDD once, these match*
>>>
>>> The next instruction of DDD that HHH emulates is at
>>> the machine address of 00002183.
>>>
>>> The next instruction of DDD that HHH1 emulates is at
>>> the machine address of 00002190.
>>>
>>> 00002183 != 00002190
>>>
>>> _DDD()
>>> [00002183] 55             push ebp
>>> [00002184] 8bec           mov ebp,esp
>>> [00002186] 6883210000     push 00002183 ; push DDD
>>> [0000218b] e833f4ffff     call 000015c3 ; call HHH
>>> [00002190] 83c404         add esp,+04
>>> [00002193] 5d             pop ebp
>>> [00002194] c3             ret
>>> Size in bytes:(0018) [00002194]
>>>
>>> _main()
>>> [000021a3] 55             push ebp
>>> [000021a4] 8bec           mov ebp,esp
>>> [000021a6] 6883210000     push 00002183 ; push DDD
>>> [000021ab] e843f3ffff     call 000014f3 ; call HHH1
>>> [000021b0] 83c404         add esp,+04
>>> [000021b3] 33c0           xor eax,eax
>>> [000021b5] 5d             pop ebp
>>> [000021b6] c3             ret
>>> Size in bytes:(0020) [000021b6]
>>>
>>>    machine   stack     stack     machine    assembly
>>>    address   address   data      code       language
>>>    ========  ========  ========  ========== =============
>>> <main is executed>
>>> [000021a3][0010382d][00000000] 55         push ebp      ; main()
>>> [000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main()
>>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
>>> [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
>>> </main is executed>
>>>
>>> New slave_stack at:1038d1
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9
>>>
>>> <DDD emulated by HHH1>
>>> [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
>>> [00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1
>>> [00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
>>> [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
>>> </DDD emulated by HHH1>
>>>
>>> New slave_stack at:14e2f9
>>> Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301
>>>
>>> <DDD emulated by HHH>
>>> [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
>>> [00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
>>> [00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
>>> [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH
>>> <DDD emulated by HHH>
>>>
>>> New slave_stack at:198d21  DDD emulated by HHH
>>> *This is the beginning of the divergence of the behavior*
>>> *HHH is emulating itself emulating DDD, HHH1 never does that*
>>>
>>> <DDD emulated by HHH emulating itself>
>>> [00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
>>> [00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
>>> [00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
>>> [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
>>> </DDD emulated by HHH emulating itself>
>>>
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>> HHH returns to caller
>>>
>>> <DDD emulated by HHH1>
>>> [00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1
>>> [00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
>>> [00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
>>> </DDD emulated by HHH1>
>>>
>>> <main is executed>
>>> [000021b0][0010382d][00000000] 83c404     add esp,+04 ; main()
>>> [000021b3][0010382d][00000000] 33c0       xor eax,eax ; main()
>>> [000021b5][00103831][00000018] 5d         pop ebp     ; main()
>>> [000021b6][00103835][00000000] c3         ret         ; main()
>>> </main is executed>
>>> Number of Instructions Executed(352831) == 5266 Pages
>>
>> The HP is asking for such a H that H(D)==1 iff D() halts.
>> You are always solving POO Problem.
>>
> 
> int main()
> {
>    DDD(); // The HHH(DDD) that DDD calls cannot report
> }        // on the behavior of its caller.
> 

Of course it must, as it must answer about the program its input 
describes, which just happens to be its caller.

But of course, FIRST you need to fix the input so it IS a program, by 
including the code of the PROGRAM HHH, which means you need to fix that 
by making your HHH an actual program by deciding exactly what its 
algorithm steps are (and get the right answer isn't an algorithm step)

Then, HHH needs to give the CORRECT answer for the behavior of that 
program DDD, which is HHH returns an answer, will ALWAYS be halting, but 
of course, from your explaination of what HHH does, it will never do 
that, as you have proved that there is no possible algorithm that you 
can put into that HHH that meets your requirements to emulate the input 
to that final state, so it will always return 0 (or fails to answer).

Sorry but you ARE obviously working on some other problem, and because 
of the major deviations in definitions, it isn't in the classic 
Computability Theory, but in your POOPS (Peter Olcotts Other Programing 
Sysstem), and no one really cares about your POOPS.