XPost: comp.theory, sci.logic   
   From: polcott333@gmail.com   
      
   On 6/25/2025 2:59 AM, Fred. Zwarts wrote:   
   > Op 24.jun.2025 om 16:06 schreef olcott:   
   >> On 6/24/2025 2:54 AM, Fred. Zwarts wrote:   
   >>> Op 23.jun.2025 om 16:50 schreef olcott:   
   >>>> On 6/23/2025 3:24 AM, Fred. Zwarts wrote:   
   >>>>> Op 22.jun.2025 om 21:27 schreef olcott:   
   >>>>>> On 6/22/2025 11:01 AM, Fred. Zwarts wrote:   
   >>>>>>> Op 20.jun.2025 om 16:53 schreef olcott:   
   >>>>>>>> On 6/20/2025 4:42 AM, Fred. Zwarts wrote:   
   >>>>>>>>> Op 19.jun.2025 om 17:23 schreef olcott:   
   >>>>>>>>>> On 6/19/2025 3:55 AM, Fred. Zwarts wrote:   
   >>>>>>>>>>> Op 18.jun.2025 om 17:41 schreef olcott:   
   >>>>>>>>>>>> On 6/18/2025 4:36 AM, Fred. Zwarts wrote:   
   >>>>>>>>>>>>> Op 17.jun.2025 om 16:36 schreef olcott:   
   >>>>>>>>>>>>>> On 6/17/2025 4:28 AM, Fred. Zwarts wrote:   
   >>>>>>>>>>>>>>> Op 17.jun.2025 om 00:26 schreef olcott:   
   >>>>>>>>>>>>>>>> On 6/16/2025 3:53 AM, Fred. Zwarts wrote:   
   >>>>>>>>>>>>>>>>> Op 15.jun.2025 om 22:10 schreef olcott:   
   >>>>>>>>>>>>>>>>>> void DDD()   
   >>>>>>>>>>>>>>>>>> {   
   >>>>>>>>>>>>>>>>>>    HHH(DDD);   
   >>>>>>>>>>>>>>>>>>    return;   
   >>>>>>>>>>>>>>>>>> }   
   >>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>> When I challenge anyone to show the details of exactly   
   >>>>>>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination   
   >>>>>>>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated   
   >>>>>>>>>>>>>>>>>> "return"   
   >>>>>>>>>>>>>>>>>> statement final halt state they ignore this challenge.   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>> It seems very difficult for you to read.   
   >>>>>>>>>>>>>>>>> We clearly stated that the challenge is improper.   
   >>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>> Are you too stupid to understand that dogmatic   
   >>>>>>>>>>>>>>>> assertions that are utterly bereft of any supporting   
   >>>>>>>>>>>>>>>> reasoning DO NOT COUNT AS REBUTTALS ???   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> No, you are too stupid to realise that challenging for a   
   >>>>>>>>>>>>>>> recipe to draw a square circle does not count as a proof   
   >>>>>>>>>>>>>>> that square circles exist.   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>> Claiming that I made a mistake with no ability to   
   >>>>>>>>>>>>>>>> show this mistake is DISHONEST.   
   >>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> Indeed, but irrelevant,   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> That alternative is that you are dishonest.   
   >>>>>>>>>>>>>> When you claim that I am wrong and have   
   >>>>>>>>>>>>>> no ability to show how and where I am wrong   
   >>>>>>>>>>>>>> this would seem to make you a liar.   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> No one has ever even attempted to show the details   
   >>>>>>>>>>>>>> of how this is not correct:   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> void DDD()   
   >>>>>>>>>>>>>> {   
   >>>>>>>>>>>>>>    HHH(DDD);   
   >>>>>>>>>>>>>>    return;   
   >>>>>>>>>>>>>> }   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> When one or more instructions of DDD are correctly   
   >>>>>>>>>>>>>> simulated by ANY simulating termination analyzer HHH   
   >>>>>>>>>>>>>> then this correctly simulated DDD never reaches its   
   >>>>>>>>>>>>>> simulated "return" statement final halt state.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>> Indeed, HHH fails to reach the end of the simulation, even   
   >>>>>>>>>>>>> though the end is only one cycle further from the point   
   >>>>>>>>>>>>> where it gave up the simulation.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> That is counter-factual and over-your-head.   
   >>>>>>>>>>>>   
   >>>>>>>>>>>   
   >>>>>>>>>>> No evidence presented for this claim. Dreaming again?   
   >>>>>>>>>>> Even a beginner understands that when HHH has code to abort   
   >>>>>>>>>>> and halt, the simulated HHH runs one cycle behind the   
   >>>>>>>>>>> simulating HHH, so that when the simulating HHH aborts, the   
   >>>>>>>>>>> simulated HHH is only one cycle away from the same point.   
   >>>>>>>>>>   
   >>>>>>>>>> Proving that you do not understand what unreachable code is.   
   >>>>>>>>>> First year CS students and EE majors may not understand this.   
   >>>>>>>>>> All CS graduates would understand this.   
   >>>>>>>>>   
   >>>>>>>>> That you do not understand what I write makes it difficult for   
   >>>>>>>>> you to learn from your errors.   
   >>>>>>>>> It is not that difficult. Try again and pay full attention to it.   
   >>>>>>>>> Even a beginner understands that when HHH has code to abort and   
   >>>>>>>>> halt,   
   >>>>>>>>> the simulated HHH runs one cycle behind the simulating HHH, so   
   >>>>>>>>> that when the simulating HHH aborts, the simulated HHH is only   
   >>>>>>>>> one cycle away from the same point.   
   >>>>>>>>   
   >>>>>>>> Yes this is factual.   
   >>>>>>>>   
   >>>>>>>> *This is only ordinary computer programming with*   
   >>>>>>>> *no theory of computation computer science required*   
   >>>>>>>>   
   >>>>>>>> Every simulated HHH remains one cycle behind its simulator   
   >>>>>>>> no matter how deep the recursive simulations go. This means   
   >>>>>>>> that the outermost directly executed HHH reaches its abort   
   >>>>>>>> criteria first.   
   >>>>>>>   
   >>>>>>> And it fails to see that the simulated HHH would reach exactly   
   >>>>>>> the same abort criteria one cycle later.   
   >>>>>>> In this way, it misses the fact that it is simulating an HHH that   
   >>>>>>> would abort and halt.   
   >>>>>>>   
   >>>>>>   
   >>>>>> void Infinite_Loop()   
   >>>>>> {   
   >>>>>>    HERE: goto HERE;   
   >>>>>>    printf("Fred Zwarts can't understand this is never reached\n");   
   >>>>>> }   
   >>>>>>   
   >>>>> Another claim without any evidence.   
   >>>>>   
   >>>>> Olcott does not understand that his HHH does not see an infinite loop.   
   >>>>> It aborts and halt, so the recursion is finite.   
   >>>>   
   >>>> You didn't even use the term recursion correctly.   
   >>>> Infinite loops have nothing to do with recursion.   
   >>>   
   >>> And infinite loops have nothing to do with a simulator simulating   
   >>> itself. Therefore, talking about infinite loops is changing the subject.   
   >>>   
   >>>> Mike understands that HHH could recognize an infinite   
   >>>> loop correctly.   
   >>>>   
   >>>>     The process in which a function calls itself directly   
   >>>>     or indirectly is called recursion and the corresponding   
   >>>>     function is called a recursive function.   
   >>>> https://www.geeksforgeeks.org/introduction-to-recursion-2/   
   >>>>   
   >>>> Lines 987 to 992 is where infinite loops are recognized   
   >>>> Lines 996 to 1005 is where infinite recursion is recognized   
   >>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c   
   >>>>   
   >>>> HHH correctly emulates the x86 machine code of its   
   >>>> input until one of those two patterns is matched.   
   >>>   
   >>> But there is a bug in the code that tries to recognise an infinite   
   >>> recursion.   
   >>   
   >> There is no bug. Quit your defamation.   
   >>   
   >>> It forgets to count the conditional branch instructions when   
   >>> simulating the simulator.   
   >>   
      
   [continued in next message]   
      
   --- SoupGate-DOS v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)