XPost: comp.theory   
   From: richard@damon-family.org   
      
   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,   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)