Re: DD emulated by HHH cannot possibly terminate normally --- x86 code

On 3/1/25 11:41 PM, olcott wrote:

On 3/1/2025 7:14 PM, Richard Damon wrote:

On 3/1/25 6:58 PM, olcott wrote:

On 3/1/2025 3:58 PM, Richard Damon wrote:

On 3/1/25 2:01 PM, olcott wrote:

On 3/1/2025 10:05 AM, Richard Damon wrote:

On 3/1/25 9:41 AM, olcott wrote:

On 3/1/2025 6:49 AM, Richard Damon wrote:

On 2/28/25 7:47 PM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]
>
When we hypothesize that the code at machine address
0000213c is an x86 emulator then we know that DD
remains stuck in recursive emulation and cannot possibly
reach its own "ret" instruction and terminate normally.
>
When we add the additional complexity that HHH also
aborts this sequence at some point then every level
of recursive emulation immediately stops. This does
not enable any DD to ever reach its "ret" instruction.
>

>
But then you just negated your first assumption, as a partial emulator that aborts its emulation, then DD no longer gets stuck.
>

>
Cannot possibly reach its own "ret" instruction and terminate normally
proves non-termination whether aborted or not.
>
Cannot possibly reach its own "ret" instruction and terminate normally
proves non-termination whether aborted or not.
>
Cannot possibly reach its own "ret" instruction and terminate normally
proves non-termination whether aborted or not.
>
>

>
But it DOES terminate

>
DD emulated by HHH never terminates no matter how many
times you try to get away with the straw-man deception
of referring to anything at all besides
>
DD EMULATED BY HHH
DD EMULATED BY HHH
DD EMULATED BY HHH
DD EMULATED BY HHH
DD EMULATED BY HHH
DD EMULATED BY HHH
>
>

>
Which since HHH doesn't correctly emulate DD is just a fantasy.
>

>
If it was actually incorrect then someone could show
how the above code is correctly emulated by HHH.

>
How? if HHH doesn't correctly do the emulation, then it doesn't do a correct emulation, and changing it to do so isn't valid.
>

 If you cannot provide an actual correct emulation
that differs from the one that I provided then
you have no basis what-so-ever to say that mine incorrect.
 IF I AM WRONG THEN SHOW WHAT IS RIGHT
IF YOU CANNOT SHOW WHAT IS RIGHT THEN YOU ARE CLUELESS
 

Since you can't correctly emulate what isn't there, your problem is incorrect by definition.
An decider, and a program reperesentation, need to be of PURE functions, which means they can't use anything other than executing their own code, and looking at their input.
Since the contents of 000015c3 hasn't been provided as part of the input, it can not be used, and thus we can't emulate the instruction after it.
Sorry, you are just proving that you have no idea of what you are talking about.
If you want a trace per your standards:
On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
 > void H_Hat(u32 P)
 > {
 >  u32 Input_Halts = Halts(P, P);
 >  if (Input_Halts)
 >    HERE: goto HERE;
 > }
 >
 >
 > int main()
 > {
 >  H_Hat((u32)H_Hat);
 > }
 >
 >
 > _H_Hat()
 > [00000b98](01)  55                  push ebp
 > [00000b99](02)  8bec                mov ebp,esp
 >
[00000b9b](01)  51                  push ecx
 > [00000b9c](03)  8b4508              mov eax,[ebp+08]
 > [00000b9f](01)  50                  push eax
 > [00000ba0](03)  8b4d08              mov ecx,[ebp+08]
 > [00000ba3](01)  51                  push ecx
 > [00000ba4](05)  e88ffdffff          call 00000938
 > [00000ba9](03)  83c408              add esp,+08
 > [00000bac](03)  8945fc              mov [ebp-04],eax
 > [00000baf](04)  837dfc00            cmp dword [ebp-04],+00
 > [00000bb3](02)  7402                jz 00000bb7
 > [00000bb5](02)  ebfe                jmp 00000bb5
 > [00000bb7](02)  8be5                mov esp,ebp
 > [00000bb9](01)  5d                  pop ebp
 > [00000bba](01)  c3                  ret
 > Size in bytes:(0035) [00000bba]
 >
 > _main()
 > [00000bc8](01)  55                  push ebp
 > [00000bc9](02)  8bec                mov ebp,esp
 > [00000bcb](05)  68980b0000          push 00000b98
 > [00000bd0](05)  e8c3ffffff          call 00000b98
 > [00000bd5](03)  83c404              add esp,+04
 > [00000bd8](02)  33c0                xor eax,eax
 > [00000bda](01)  5d                  pop ebp
 > [00000bdb](01)  c3                  ret
 > Size in bytes:(0020) [00000bdb]
 >
 > ===============================
 > ...[00000bc8][001015d4][00000000](01)  55         push ebp
 > ...[00000bc9][001015d4][00000000](02)  8bec       mov ebp,esp
 > ...[00000bcb][001015d0][00000b98](05)  68980b0000 push 00000b98
 > ...[00000bd0][001015cc][00000bd5](05)  e8c3ffffff call 00000b98
 > ...[00000b98][001015c8][001015d4](01)  55         push ebp
 > ...[00000b99][001015c8][001015d4](02)  8bec       mov ebp,esp
 > ...[00000b9b][001015c4][00000000](01)  51         push ecx
 > ...[00000b9c][001015c4][00000000](03)  8b4508     mov  eax,[ebp+08]
 > ...[00000b9f][001015c0][00000b98](01)  50         push eax
 > ...[00000ba0][001015c0][00000b98](03)  8b4d08     mov ecx,[ebp+08]
 > ...[00000ba3][001015bc][00000b98](01)  51         push ecx
 > ...[00000ba4][001015b8][00000ba9](05)  e88ffdffff call 00000938
 > Begin Local Halt Decider Simulation at Machine Address:b98
 > ...[00000b98][00211674][00211678](01)  55         push ebp
 > ...[00000b99][00211674][00211678](02)  8bec       mov ebp,esp
 > ...[00000b9b][00211670][00201644](01)  51         push ecx
 > ...[00000b9c][00211670][00201644](03)  8b4508     mov eax,[ebp+08]
 > ...[00000b9f][0021166c][00000b98](01)  50         push eax
 > ...[00000ba0][0021166c][00000b98](03)  8b4d08     mov ecx,[ebp+08]
 > ...[00000ba3][00211668][00000b98](01)  51         push ecx
 > ...[00000ba4][00211664][00000ba9](05)  e88ffdffff call 00000938
 > ...[00000b98][0025c09c][0025c0a0](01)  55         push ebp
 > ...[00000b99][0025c09c][0025c0a0](02)  8bec       mov ebp,esp
 > ...[00000b9b][0025c098][0024c06c](01)  51         push ecx
 > ...[00000b9c][0025c098][0024c06c](03)  8b4508     mov eax,[ebp+08]
 > ...[00000b9f][0025c094][00000b98](01)  50         push eax
 > ...[00000ba0][0025c094][00000b98](03)  8b4d08     mov ecx,[ebp+08]
 > ...[00000ba3][0025c090][00000b98](01)  51         push ecx
 > ...[00000ba4][0025c08c][00000ba9](05)  e88ffdffff call 00000938
 > Local Halt Decider: Infinite Recursion Detected Simulation Stopped
Above decision was from the call the Halts inside H_Hat, deciding that H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is processed below:
 > ...[00000ba9][001015c4][00000000](03)  83c408     add esp,+08
 > ...[00000bac][001015c4][00000000](03)  8945fc     mov [ebp-04],eax
 > ...[00000baf][001015c4][00000000](04)  837dfc00   cmp dword [ebp-04],+00
 > ...[00000bb3][001015c4][00000000](02)  7402       jz 00000bb7
 > ...[00000bb7][001015c8][001015d4](02)  8be5       mov esp,ebp
 > ...[00000bb9][001015cc][00000bd5](01)  5d         pop ebp
 > ...[00000bba][001015d0][00000b98](01)  c3         ret
 > ...[00000bd5][001015d4][00000000](03)  83c404     add esp,+04
 > ...[00000bd8][001015d4][00000000](02)  33c0       xor eax,eax
 > ...[00000bda][001015d8][00100000](01)  5d         pop ebp
 > ...[00000bdb][001015dc][00000098](01)  c3         ret
SEE IT HALTED!
Yes, this is of H_Hat calling H, not DD calling HHH, but they are of the same form, so it is a valid trace.
This is what a *CORRECT* emulation of the input to HHH would do, it would see HHH doing the emulation, aborting and then returning 0 to DD.
That you refuese to accept this, just proves that you are so stupid you can't see the truth,