Re: Any honest person that knows the x86 language can see... DDD will HALT if HHH answers

On 7/29/24 10:07 AM, olcott wrote:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.
 

No they don't.
Infinite_Recursion calls Infinite_Recursion without any conditional instructions in the full cycle.
DDD calls HHH(DDD) which does a CONDITIONAL emul

Correct emulation is defined as emulating the machine language
input according to the x86 semantics specified by this input.

Right, which HHH doesn't do, since that would require it correctly emulating the instructions within HHH

 For DDD correctly emulated by HHH this includes HHH emulating
itself emulating DDD according to the x86 semantics of itself.

Right, which it doesn't do. Note, that is NOT look at the emulation that HHH does, it is look at HHH doing the emulation.

 HHH(DDD) shows the exact same execution trace behavior pattern
as HHH(Infinite_Recursion) where 3-4 instructions are repeated
with no conditional branch instructions in this trace that could
prevent them from endlessly repeating.

Nope, because HHH(DDD) sees DDD call HHH, not DDD, and thus the CORRECT emulation of this needs to look at the ACTUAL BEHAVIOR of the code of HHH, which it doesn't do.
You are just showing that you are totally ignorant of what you are trying to talk about,

 void Infinite_Recursion()
{
   Infinite_Recursion();
}
 _Infinite_Recursion()
[0000215a] 55         push ebp      ; 1st line
[0000215b] 8bec       mov ebp,esp   ; 2nd line
[0000215d] e8f8ffffff call 0000215a ; 3rd line
[00002162] 5d         pop ebp
[00002163] c3         ret
Size in bytes:(0010) [00002163]
 *THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113934
[0000215a][00113924][00113928] 55         push ebp      ; 1st line
[0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line
[0000215a][0011391c][00113924] 55         push ebp      ; 1st line
[0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
 If you cannot see that the above x86 machine code proves that
it will never halt then you can't possibly understand what I
have been saying.
 The first three lines of _Infinite_Recursion() repeat and there
are no conditional branch in that sequence that can possibly keep
it from repeating forever.
 HHH(DDD) is the exact same pattern is shown below. The first
four lines of DDD repeat and there are are no conditional branch
in that sequence that can possibly keep it from repeating forever.

Nope.

 void DDD()
{
   HHH(DDD);
}
 _DDD()
[00002177] 55               push ebp      ; 1st line
[00002178] 8bec             mov ebp,esp   ; 2nd line
[0000217a] 6877210000       push 00002177 ; push DDD
[0000217f] e853f4ffff       call 000015d7 ; call HHH
[00002184] 83c404           add esp,+04
[00002187] 5d               pop ebp
[00002188] c3               ret
Size in bytes:(0018) [00002188]
 *FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895
[00002177][00113885][00113889] 55         push ebp      ; 1st line
[00002178][00113885][00113889] 8bec       mov ebp,esp   ; 2nd line
[0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH

And the below is *NOT* the correct emulation of what a call HHH does.
Proving you have inadequate knowledge of the x86 processor to be making your claims.

 [00002177][0015e2ad][0015e2b1] 55         push ebp      ; 1st line
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp   ; 2nd line
[0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
 Because HHH has no idea that it is calling itself HHH only sees
the same Infinite Recursion behavior pattern that it saw with
Infinite_Recursion().
 

If it has no idea it is calling itself, why does it think that a call to 000015d7 will cause an emulation of the program at the address on the top of the stack?
If it has been "told" that at 000015d7 is an unconditional emulator, it has been programmed incorrectly, and thus is just flawed, and the programmer (which was you) is just a LIAR.
So, HHH just doesn't do what you claim, so I guess you are just admitting to being that ignorant pathological lying idiot that just has a reckless disregard for the truth,