XPost: sci.math, comp.theory   
   From: 643-408-1753@kylheku.com   
      
   On 2025-11-27, olcott  wrote:   
   > On 11/26/2025 10:15 PM, Kaz Kylheku wrote:   
   >> On 2025-11-27, olcott  wrote:   
   >>> On 11/26/2025 8:00 PM, Python wrote:   
   >>>>> Kaz is saying that he can "resume" a simulation   
   >>>>> that has just proved that it will never stop   
   >>>>> running to a different machine state to "prove"   
   >>>>> that this simulation does stop running.   
   >>>>   
   >>>> He is right.   
   >>>>   
   >>>   
   >>> He is resuming a simulation that he already admitted   
   >>> that he conclusively proved is non-halting to contradict   
   >>   
   >> What? I did not. You must be brandishing your second   
   >> grade level reading comprehension again.   
   >>   
   >>> himself and prove that it is halting by "resuming" this   
   >>> simulation at a different machine state.   
   >>   
   >> The simulation is resumed at exactly the simulation's   
   >> current state as it was left behind when the decider   
   >> stopped stepping it.   
   >   
   > Unless it is the total machine state it is cheating.   
      
   You idiot, what you are proposing is to turn back time over   
   the entire apparatus. That will would create an instant loop, like in   
   time-travel science fiction.   
      
   The techniqjue I implemented, which is apparently beyond   
   your understanding, doesn't involve rewinding anything.   
      
   There is no manpulation of state other than /identifyng/   
   a simulation that has been abandoned and then stepping it   
   forward by making more DebugStep calls that the decider   
   refused to make.   
      
   There is no rewinding or replay going on.   
      
   >> But don't take my word for it. You could check it in   
   >> the actual ... code!   
   >>   
   >> You are just not good at following the semantics of   
   >> the C language and the x86 instruction set.   
   >>   
   >   
   > Here is the dumbed down version   
      
   All you are capable of.   
      
   > void DDD()   
   > {   
   >    HHH(DDD);   
   >    return;   
   > }   
   >   
   > HHH simulates DDD that calls HHH(DDD)   
   > that simulates DDD that calls HHH(DDD)...   
   >   
   > How is this DDD going to reach its "return" statement???   
      
   It has been explained umpteen times.   
      
   It reaches that statement in exactly the same way the top-level DDD()   
   called from main() does.   
      
   I can answer questions about it, but at some point you   
   have to do your own experimenting.   
      
   I've given you the tool to see where abandoned simulations   
   are heading; you can /use/ that as a debugging/verification   
   tool to make sure that the simulations do what you think   
   (and publicly say) they do.   
      
   You have static variable cheats in your code which enable   
   you to get that behavior.   
      
   Here is the kicker:   
      
   * It's only because your cheats are not completely working that I obtained   
   * the expected results!!! Mike Terry identified this first.   
      
   Here is hat happens: HHH simulates DDD, performing the abort tests.   
   DDD starts a level [2] simulation. That simulation also calls HHH   
   and when it hits that address, the abort criteria kick in: the outer   
   HHH bails and returns 0.   
      
   Now we get to the kicker: before returning, HHH overwrites the   
   static execution trace buffer pointer wth 0x90909090.   
      
   Now, we resume the abandoned level [1] simulation. What happens is that   
   the level [2] simulation now continues executing into HHH.  This level   
   [2] HHH notices, "hey, I don't have an execution trace buffer: the   
   pointer is 0x90909090".  It therefore allocates one and thinks that it   
   is the Root decider (Root == 1).  Therefore, the level [2] HHH performs   
   the abort test, and eventually returns 0 to the level [2] DDD. That DDD   
   then terminates whch is detected by the level [1] HHH, which returns 0.   
   The level [1] DD then terminates, and so ends the level[1] simulation   
   that we resumed.   
      
   So by dumb luck, we observe the "correct" behavior; your stupid   
   cheat fucked itself by resetting the trace buffer pointer.   
      
   Most of my remarks refer to a correctly implemented, de-fuckerized   
   version of your test case without the static data, in which HHH,   
   DD and all those are pure functions.   
      
   Mike Terry implemented something like that,  "MTJ_HHH" and "MJT_DD".   
   He saw the infinite tower of termnating simuations start up,   
   and proceed into several levels.   
      
   --   
   TXR Programming Language: http://nongnu.org/txr   
   Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal   
   Mastodon: @Kazinator@mstdn.ca   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)