[continued from previous message]   
      
   >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,   
   >>>>>    if Ĥ applied to ⟨Ĥ⟩ halts, and   
   >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   
   >>>>>    if Ĥ applied to ⟨Ĥ⟩ does not halt.   
   >>>>>   
   >>>>> <*Halting Problem Proof ERROR*>   
   >>>>>   
   >>>>> Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the   
   >>>>> direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not   
   >>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.   
   >>>>>   
   >>>>> No Turing Machine decider can ever report on the   
   >>>>> behavior of anything that is not an input encoded   
   >>>>> as a finite string.   
   >>>>>   
   >>>>> Ĥ is not a finite string input to Ĥ.embedded_H   
   >>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ are finite string inputs to Ĥ.embedded_H   
   >>>>>   
   >>>>>    
   >>>>>   
   >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞   
   >>>>>      ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches   
   >>>>>      its simulated final halt state of ⟨Ĥ.qn⟩, and   
   >>>>>   
   >>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   
   >>>>>      ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly   
   >>>>>      reach its simulated final halt state of ⟨Ĥ.qn⟩.   
   >>>>>   
   >>>>> When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a   
   >>>>> simulating partial halt decider   
   >>>>> (a) Ĥ copies its input ⟨Ĥ⟩   
   >>>>> (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩   
   >>>>> (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩   
   >>>>> (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩   
   >>>>> (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩   
   >>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩   
   >>>>> (g) goto (d) with one more level of simulation until   
   >>>>> *embedded_H sees the repeating pattern and transitions to Ĥ.qn*   
   >>>>   
   >>>> But when this is only finite repeating pattern,   
   >>>   
   >>> The infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H   
   >>> cannot possibly reach its own simulated final   
   >>> halt state of ⟨Ĥ.qn⟩ you fucking moron.   
   >>>   
   >> But that infinite simulation exists only in your dreams and is   
   >> counter- factual. Ĥ aborts and the same abort code is present in   
   >> embedded_H (unless you are cheating), so there is no infinite   
   >> recursion, no infinite repeating pattern. The correct simulation will   
   >> reach the final halt state.   
   >   
   > When you change my words and use those words as the basis   
   > of your rebuttal you know that you cheat.   
   >   
   > The infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H   
   > cannot possibly reach its own simulated final   
   > halt state of ⟨Ĥ.qn⟩ you fucking moron.   
      
   Which is just a strawman, as the definition of non-halting behavior of   
   the input, is that when the machine the input describes, in this case   
   the machibe Ĥ ⟨Ĥ⟩, will never stop running when run, even if carried out   
   to an unbounded number of steps, but since H and thus embedded_H which   
   is a copy of it DO abort their simulations and go to Qn and thus the   
   actual machine Ĥ ⟨Ĥ⟩ halts, it must be wrong.   
      
   Basing your arguement on Strawmen, even after the error has been pointed   
   out just establishes that you are just a pathological liar.   
      
   >   
   >>  We know that Ĥ fails to do this correct simulation. And performs a   
   >> premature abort before it reaches that final halt state. Aborting a   
   >> simulation before it can reach the final halt state is no measure for   
   >> non-halting behaviour, it is only evidence that simulation is not the   
   >> right too for this input to determine halting behaviour.   
   >   
   >   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)