XPost: comp.theory, sci.logic   
   From: polcott333@gmail.com   
      
   On 8/4/2025 7:25 AM, Fred. Zwarts wrote:   
   > Op 02.aug.2025 om 17:03 schreef olcott:   
   >> On 8/2/2025 4:38 AM, Fred. Zwarts wrote:   
   >>> Op 02.aug.2025 om 04:09 schreef olcott:   
   >>>> On 8/1/2025 8:01 PM, Mr Flibble wrote:   
   >>>>> Olcott, give it a fucking rest: what you are banging on about has   
   >>>>> nothing   
   >>>>> to do with the Halting Problem.   
   >>>>>   
   >>>>> Damon, stop feeding Olcott: you are just talking over each other at   
   >>>>> this   
   >>>>> point.   
   >>>>>   
   >>>>> /Flibble   
   >>>>   
   >>>> Every attempt to refute me has been counter-factual.   
   >>>> The survival of life an Earth depends on a correct   
   >>>> understanding of truth.   
   >>>>   
   >>>> The Tarski Undefinability theorem that incorrectly   
   >>>> "proves" that a Boolean True(L,x) predicate cannot   
   >>>> be consistently defined relies on the same structure   
   >>>> as the conventional HP proofs.   
   >>>>   
   >>>> Because of this humans have no perfectly objective   
   >>>> way to discern truth from very well crafted lies,   
   >>>> thus the well crafted lies win.   
   >>>>   
   >>>> Richard is still trying to get away with saying that   
   >>>> the repeating pattern shown below does not exist.   
   >>>>   
   >>>> void DDD()   
   >>>> {   
   >>>>    HHH(DDD);   
   >>>>    return;   
   >>>> }   
   >>>>   
   >>>> HHH simulates DDD that calls HHH(DDD)   
   >>>> that simulates DDD that calls HHH(DDD)   
   >>>> that simulates DDD that calls HHH(DDD)   
   >>>> that simulates DDD that calls HHH(DDD)   
   >>>> that simulates DDD that calls HHH(DDD)   
   >>>> that simulates DDD that calls HHH(DDD)   
   >>>> that simulates DDD that calls HHH(DDD)   
   >>>> that simulates DDD that calls HHH(DDD)   
   >>>> that simulates DDD that calls HHH(DDD)   
   >>>>   
   >>>   
   >>> As usual incorrect claims without evidence.   
   >>   
   >> I am not going to repeat all of the lines of my proof   
   >> every single time. That I presented all of the lines   
   >> of my proof once is sufficient to refute your claims   
   >> of no evidence.   
   >   
   > As usual repeated incorrect claims without evidence. There never has   
   > been a proof.   
   >   
   >>   
   >>> A finite recursion is not a non-halting behaviour.   
   >>>   
   >>   
   >> Finite recursion by itself is not non-halting behavior.   
   >> Finite recursion that correctly detects a pattern that   
   >> would infinitely repeat *IS NON-HALTING BEHAVIOR*   
   >   
   > As usual irrelevant remarks.   
   > There is no such pattern. There is only a finite recursion, after which   
   > the program halts. That is what the code of the input specifies. That   
   > HHH does not see it, does not change the specification.   
   > The code specifies a finite recursion, followed by an abort by the   
   > simulated HHH. HHH does not se that, because of a premature abort.   
   >   
   >>   
   >> typedef void (*ptr)();   
   >>   
   >> int Simulate(ptr x)   
   >> {   
   >>    x();   
   >>    return 1;   
   >> }   
   >>   
   >> void Infinite_Recursion()   
   >> {   
   >>    Simulate(Infinite_Recursion);   
   >>    return;   
   >> }   
   >   
   >   
   > Again, irrelevant examples.   
   > The input for HHH is more like:   
   >   
   > void Finite_Recursion () {   
   >    static int N = 5;   
   >    if (N > 0) Finite_Recursion ();   
   >    printf ("Olcott thinks this is never printed.\n");   
   > }   
   >   
   >>   
   >> HHH detects the behavior pattern where Infinite_Recursion()   
   >> cannot possibly reach its own final halt state and it does   
   >> this in finite steps.   
   >>   
   >   
   >   
   > But HHH does not recognise that there is only a finite recursion in the   
   > simulated HHH, because it does not keep track of the internal state of   
   > the simulated HHH and its conditional branch instructions.   
   >   
   >>> You are trying to get away with the idea that if you close your eyes   
   >>> for the halting behaviour, it does not exists.   
   >>   
   >> Not at all. I repeatedly challenge you to show how   
   >> DDD emulated by HHH halts and you change the subject.   
   >> Changing the subject this way is known as the strawman error.   
   >   
   >   
   > Yes, you keep closing your eyes for the errors in HHH and that it not   
   > possible to correct them.   
   > You also use the strange logic that if no correction exists, HHH must be   
   > correct.   
   >   
   >>   
   >> A straw man fallacy (sometimes written as strawman)   
   >> is the informal fallacy of refuting an argument   
   >> different from the one actually under discussion,   
   >> while not recognizing or acknowledging the distinction.   
   >> https://en.wikipedia.org/wiki/Straw_man   
   >   
   > Why are you using straw man fallacies, if you know that the have no   
   > value? That looks very dishonest.   
   >   
   >>   
   >>> The simulating HHH aborts before it reaches the final halt state of   
   >>> the simulated HHH that has the same code to abort, so it does not see   
   >>> it and pretends that it does not exist.   
   >>>   
   >>   
   >> Each HHH aborts as soon as it has seen one recursive simulation.   
   >   
   > But only a finite recursion, where correct simulaters show that for the   
   > exact same input only one more recursion is needed to reach the final   
   > halt state.   
   >   
   >> We could change this to each HHH aborts after it sees N recursive   
   >> simulations. In every case the outer HHH meets its criteria first.   
   >> If this HHH waited for the next, they would all wait for the next   
   >> and no abort would ever occur.   
   >   
   > Only, if you change the input. If you increase N, but use the same   
   > input, then we see that it reaches the final halt state.   
   > Of, cours, with this other new HHH, we can construct another new DDD,   
   > for which this HHH will fail to. The only think you do is proving that   
   > it is impossible to create an HHH that is correct for all possible inputs.   
   >   
   >>   
   >>> Changing the meaning of the words will not help you to find the truth.   
   >>   
   >> I don't change the meaning of words. I correct the erroneous   
   >> ambiguity of the meaning or words. I also correct the definitions   
   >> of the meaning of words when these definitions directly contradict   
   >> other definitions.   
   >   
   > No, you change the meaning of the words.   
   > A finite recursion is not non-halting behaviour.   
   >   
   >>   
   >> The input to a halt decider specifies its behavior.   
   >> Directly executed Turing machines are outside of the   
   >> domain of every halt decider.   
   >>   
   >   
   > Yes, but when the input specifies a finite recursion, followed by a   
   > final halt state, HHH is incorrect when it does not see that and starts   
   > to reason about a hypothetical non-input that does not halt.   
   >   
   >   
      
      
   _D4()   
   [000021c3] 55             push ebp   
   [000021c4] 8bec           mov ebp,esp   
   [000021c6] 68c3210000     push 000021c3 // push D4   
   [000021cb] e8f3f3ffff     call 000015c3 // call HHH   
   [000021d0] 83c404         add esp,+04   
   [000021d3] 5d             pop ebp   
   [000021d4] c3             ret   
   Size in bytes:(0018) [000021d4]   
      
   D4 correctly emulated by HHH cannot possibly get   
   past its own machine address [000021cb] thus the   
      
   [continued in next message]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)