XPost: comp.theory, comp.lang.c++, comp.lang.c   
   From: polcott333@gmail.com   
      
   On 8/30/2025 1:06 AM, Kaz Kylheku wrote:   
   > On 2025-08-29, olcott  wrote:   
   >> When I say something 500 times that does not   
   >> count as I said it zero times.   
   >>   
   >> DD correctly simulated by HHH specifies the   
   >> non-halting behavior pattern of recursive   
   >> simulation.   
   >   
   > Using a bit of logical formalism:   
   >   
   >     correctly_simulated(DD) -> ~ halts(DD)   
   >   
   > Given P -> Q, we can derive the contrapositive ~Q -> ~P.   
   > In this case:   
   >   
   >     ~ ~ halts(DD) -> ~ correctly_simulated(DD)   
   >   
   > Cancel double negative:   
   >   
   >     halts(DD) -> ~ correctly_simulated(DD)   
   >   
   >> If HHH can recognize this repeating state as   
   >> a pure function of its inputs then HHH(DD)   
   >> returns 0 for non-halting and DD() halts.   
   >   
   >  From this paragraph we can extract:   
   >   
   >    returns_zero(HHH(DD)) -> halts (DD)   
   >   
   > OK, so we have these propositions together:   
   >   
   >    1. returns_zero(HHH(DD)) -> halts (DD)    ;; from second paragraph   
   >   
   >    2. halts(DD) -> ~ correctly_simulated(DD) ;; from first paragraph   
   >   
   > By the transitive property of the arrow: P -> Q ^ Q -> R  =>  P -> R,   
   > therefore we have:   
   >   
   >    3. returns_zero(HHH(DD)) -> ~ correctly_simulated(DD)   
   >   
   > You are logically arguing that if HHH(DD) returns   
   > zero, then DD is not correctly simulated (because it halts).   
   >   
      
   We just use your idea of establishing   
   naming conventions:   
      
   HHH(DD).exe returns 0 because DD.sim1   
   cannot possibly halt then DD.exe halts.   
   DD.exe is outside of the scope of HHH.exe.   
      
   typedef int (*ptr)();   
   int HHH(ptr P);   
      
   int DD()   
   {   
      int Halt_Status = HHH(DD);   
      if (Halt_Status)   
        HERE: goto HERE;   
      return Halt_Status;   
   }   
      
   DD.exe is executed.   
   DD.exe calls HHH(DD).exe   
   HHH.exe simulates DD.sim1   
   DD.sim1 calls HHH(DD).sim1   
   HHH.sim1 simulates DD.sim2   
   DD.sim2 calls HHH(DD).sim2 ... This would repeat unless aborted   
   if aborted then DD.exe halts   
      
   This exact same thing happens with the Linz   
   Turing Machine based proof.   
      
   Machine M contains simulating halt decider H based on a UTM   
   M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.∞   
   M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.qn   
      
   *Repeats until aborted proving non-halting*   
   (a) M copies its input ⟨M⟩   
   (b) M invokes M.H ⟨M⟩ ⟨M⟩   
   (c) M.H simulates ⟨M⟩ ⟨M⟩   
      
   then M.H ⟨M⟩ ⟨M⟩ transitions to M.qn   
   causing M applied to ⟨M⟩ halt   
      
      
      
      
   --   
   Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius   
   hits a target no one else can see." Arthur Schopenhauer   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)