XPost: comp.theory, sci.logic   
   From: polcott333@gmail.com   
      
   *We are only addressing this one point in this thread*   
      
   On 7/29/2025 11:22 PM, Alan Mackenzie wrote:   
    > It is a lack of technical ability on your   
    > part which is unable to judge whether such   
    > a correct simulation is possible.  Everybody   
    > else sees that it is not, so further questions   
    > about it are non-sensical.   
      
   HHH emulates DDD in a separate process context. When   
   this DDD calls HHH(DDD) the original HHH emulates this   
   HHH in the DDD process context.   
      
   This emulated HHH creates yet another process context   
   to emulate its own DDD. When this DDD calls yet another   
   HHH(DDD) this provides enough execution trace that the   
   repeating pattern can be seen.   
      
   void DDD()   
   {   
      HHH(DDD);   
      return;   
   }   
      
   _DDD()   
   [00002192] 55         push ebp   
   [00002193] 8bec       mov ebp,esp   
   [00002195] 6892210000 push 00002192  // push DDD   
   [0000219a] e833f4ffff call 000015d2  // call HHH   
   [0000219f] 83c404     add esp,+04   
   [000021a2] 5d         pop ebp   
   [000021a3] c3         ret   
   Size in bytes:(0018) [000021a3]   
      
   On 7/31/2025 6:32 AM, Richard Damon wrote:   
   > On 7/30/25 11:38 PM, olcott wrote:   
   >>   
   >> If people here have much less than a computer science   
   >> degree and have never heard of any kind of multi-tasking   
   >> that may lead them to believe that HHH cannot emulate   
   >> itself emulating DDD.   
   >   
   > Who said that?   
   >   
      
   On 7/29/2025 11:22 PM, Alan Mackenzie wrote:   
    > It is a lack of technical ability on your   
    > part which is unable to judge whether such   
    > a correct simulation is possible.  Everybody   
    > else sees that it is not, so further questions   
    > about it are non-sensical.   
      
   >   
   > Oh, and this multi-tasling system wzs very badly done, as it forces all   
   > the code to use the same memory space. Maybe that is because your   
   > experience was with older processors that couldn't handle themselves the   
   > seperate memory spacee. Note, the code of x86utm that you started with   
   > didn't require that the code being simulated be at the physical memory   
   > address that it represents, That limitation is something you added to   
   > the system because you apparently don't understand the abstraction of   
   > virtual addresses.   
   >   
      
   The whole point is to show that HHH does emulate itself   
   emulating DDD because so many people believe this is   
   impossible. *All of the above critique is off-topic*   
   *It merely distracts attention away from the point*   
   >>   
   >>> When simulating DDD, we need to look at each instruciton executed in   
   >>> the context of THAT PROCESS. That will watch every instruction of the   
   >>> HHH that it calls and is thus part of that process.   
   >>>   
   >>> We watch HHH doing the simulation, not the results of that simulation   
   >>>   
   >>   
   >> Right if you want to see the actual behavior of DDD   
   >> you must make sure to not look at this behavior because   
   >> that might mislead you into telling the truth.   
   >   
   > And that behavior is DEFINED to be what it does when RUN, or COMPLETELY   
   > simulted.   
      
   *Not at all you never get this correctly even*   
   *when you have been corrected hundreds of times*   
      
   Simulating Termination Analyzer HHH correctly simulates its input until:   
   (a) It detects a non-terminating behavior pattern then it aborts its   
   simulation and returns 0,   
   (b) Its simulated input reaches its simulated "return" statement then it   
   returns 1.   
      
   >   
   > SInce that WILL HALT, DDD is HALTING, and saying anything else is just a   
   > lie.   
   >   
      
   *Not at all you never get this correctly even*   
   *when you have been corrected hundreds of times*   
      
   We are only measuring whether or not DDD correctly   
   simulated by HHH can possibly reach its own simulated   
   final halt state.   
      
   > That HHH doesn't simulate it to that point, is an error in HHH, not a   
   > problem with DDD.   
   >   
      
   That merely shows that you do not understand what   
   is actually occurring.   
      
   void DDD()   
   {   
      HHH(DDD);   
      return;   
   }   
      
   *When HHH simulates ten instructions of DDD it goes like this*   
   Executed  HHH(DDD) simulates DDD that calls HHH(DDD)   
   Simulated HHH(DDD) simulates DDD that calls HHH(DDD)   
   Simulated HHH(DDD) simulates DDD that calls HHH(DDD)   
   Simulated HHH(DDD) simulates DDD that calls HHH(DDD)   
   Simulated HHH(DDD) simulates DDD that calls HHH(DDD)   
   Simulated HHH(DDD) simulates DDD that calls HHH(DDD)   
   Simulated HHH(DDD) simulates DDD that calls HHH(DDD)   
   Simulated HHH(DDD) simulates DDD that calls HHH(DDD)   
   Simulated HHH(DDD) simulates DDD that calls HHH(DDD)   
   Simulated HHH(DDD) simulates DDD that calls HHH(DDD)   
      
   >>   
   >>>>   
   >>>> Before it does this it creates a separate simulation   
   >>>> context having its own set of 16 virtual registers and   
   >>>> its own virtual stack.   
   >>>   
   >>> Right, which isn't part of the program being simulated,   
   >>>   
   >>   
   >> HHH is the master process of all processes.   
   >> DDD is the immediate slave process.   
   >   
   > No it isn't.   
   >   
   > You may be trying to implement it that way, but DDD is DEFINED as a   
   > totally independent process, which HHH is trying to determine what it   
   > will do by looking at its code.   
   >   
      
   HHH(DDD) the slave DDD is not a totally independent process   
   it requires HHH to pump its process at each of its instructions.   
      
   >>   
   >>>   
   >>>> _DDD()   
   >>>> [0000219e] 55             push ebp   
   >>>> [0000219f] 8bec           mov ebp,esp   
   >>>> [000021a1] 689e210000     push 0000219e // push DDD   
   >>>> [000021a6] e843f4ffff     call 000015ee // call HHH   
   >>>> [000021ab] 83c404         add esp,+04   
   >>>> [000021ae] 5d             pop ebp   
   >>>> [000021af] c3             ret   
   >>>> Size in bytes:(0018) [000021af]   
   >>>   
   >>>   
   >>> Which isn't a program, and can't be simulated past the call instruction.   
   >>>   
   >>   
   >> The recursive structure of DDD cannot be easily seen   
   >> when buried in hundreds of pages of extraneous detail.   
   >   
   > Thats YOUR problem.   
   >   
      
   It has always been your mistake that I have corrected   
   many many times that you believe that HHH and DDD are   
   not in the same global block of memory of Halt7.obj.   
      
   > LYING about what happens, just shows that you are a liar.   
   >   
      
   No this is actually a case of your own dementia.   
   When I correct your false assumptions hundreds of   
   times at some point you should remember that I   
   corrected you at least once.   
      
   *Its either dementia or persistent dishonesty*   
      
   >>   
   >> So far not one person here could ever understand   
   >> one half of one page of text when given three years   
   >> to understand it.   
   >   
   > No, the one person here that doesn't understand that trace is YOU.   
   >   
   > Because you keep on lying to yourself about what you are doing.   
   >   
      
   That your dementia causes you to always forget my corrections   
      
   [continued in next message]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)