XPost: comp.theory, sci.logic   
   From: richard@damon-family.org   
      
   On 7/12/24 10:56 AM, olcott wrote:   
   > We stipulate that the only measure of a correct emulation is the   
   > semantics of the x86 programming language.   
      
   Which means the only "correct emulation" that tells the behavior of the   
   program at the input is a non-aborted one.   
      
   >   
   > _DDD()   
   > [00002163] 55         push ebp      ; housekeeping   
   > [00002164] 8bec       mov ebp,esp   ; housekeeping   
   > [00002166] 6863210000 push 00002163 ; push DDD   
   > [0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)   
   > [00002170] 83c404     add esp,+04   
   > [00002173] 5d         pop ebp   
   > [00002174] c3         ret   
   > Size in bytes:(0018) [00002174]   
   >   
   > When N steps of DDD are emulated by HHH according to the   
   > semantics of the x86 language then N steps are emulated correctly.   
      
   And thus HHH that do that know only the first N steps of the behavior of   
   DDD, which continues per the definition of the x86 instruction set until   
   the COMPLETE emulation (or direct execution) reaches a terminal instruction.   
      
   >   
   > When we examine the infinite set of every HHH/DDD pair such that:   
   > HHH₁ one step of DDD is correctly emulated by HHH.   
   > HHH₂ two steps of DDD are correctly emulated by HHH.   
   > HHH₃ three steps of DDD are correctly emulated by HHH.   
   > ...   
   > HHH∞ The emulation of DDD by HHH never stops running.   
      
   And thus, the subset that only did a finite number of steps and aborted   
   its emulation on a non-terminal instrucition only have partial knowledge   
   of the behavior of their DDD, and by returning to their caller, they   
   establish that behavior for ALL copies of that HHH, even the one that   
   DDD calls, which shows that DDD will be halting, even though HHH stopped   
   its observation of the input before it gets to that point.   
      
   >   
   > The above specifies the infinite set of every HHH/DDD pair   
   > where 1 to infinity steps of DDD are correctly emulated by HHH.   
   >   
   > No DDD instance of each HHH/DDD pair ever reaches past its   
   > own machine address of 0000216b and halts.   
      
   Wrong. EVERY DDD of an HHH that simulated its input for only a finite   
   number of steps WILL halt becuase it will reach its final return.   
      
   The HHH that simulated it for only a finite number of steps, only   
   learned that finite number of steps of the behaivor, and in EVERY case,   
   when we look at the behavior past that point, which DOES occur per the   
   definition of the x86 instruction set, as we have not reached a   
   "termial" instruction that stops behavior, will see the HHH(DDD) that   
   DDD called continuing to simulate its input to the point that this one   
   was defined to stop, and then returns 0 to DDDD and then DDD returning   
   and ending the behavior.   
      
   You continue to stupidly confuse the PARTIAL observation that HHH does   
   of the behavior of DDD by its PARTIAL emulation with the ACTUAL FULL   
   behavior of DDD as defined by the full definition of the x86 insttuction   
   set.   
      
      
   >   
   > Thus each HHH element of the above infinite set of HHH/DDD   
   > pairs is necessarily correct to reject its DDD as non-halting.   
   >   
      
   Nope.   
      
   NONE Of them CORRECTLY rejected itS DDD as non-halting and you are shown   
   to be ignorant of what you are talking about.   
      
   The HHH that did a partial emulation got the wrong answer, because THEIR   
   DDD will halt. and the HHH that doen't abort never get around to   
   rejecting its DDD as non-halting.   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)