XPost: comp.theory, comp.lang.c++, comp.lang.c   
   From: polcott333@gmail.com   
      
   On 10/5/2025 9:39 PM, André G. Isaak wrote:   
   > On 2025-10-05 20:23, olcott wrote:   
   >> On 10/5/2025 9:07 PM, André G. Isaak wrote:   
   >>> On 2025-10-05 19:46, olcott wrote:   
   >>>> On 10/5/2025 5:01 PM, André G. Isaak wrote:   
   >>>>> On 2025-10-05 15:36, olcott wrote:   
   >>>>>> On 10/5/2025 4:25 PM, André G. Isaak wrote:   
   >>>>>>> On 2025-10-05 14:29, olcott wrote:   
   >>>>>>>> On 10/5/2025 3:13 PM, André G. Isaak wrote:   
   >>>>>>>>> On 2025-10-05 13:06, olcott wrote:   
   >>>>>>>>>> On 10/5/2025 1:48 PM, André G. Isaak wrote:   
   >>>>>>>>>   
   >>>>>>>>>>> It doesn't matter how you implement your static data. Static   
   >>>>>>>>>>> data is static data. Your messy implementation doesn't solve   
   >>>>>>>>>>> the fundamental problem.   
   >>>>>>>>>>>   
   >>>>>>>>>>   
   >>>>>>>>>> The subsequent function calls are not actual   
   >>>>>>>>>> function calls.   
   >>>>>>>>>   
   >>>>>>>>> I didn't mention function calls. So I'm not sure why you think   
   >>>>>>>>> this is relevant.   
   >>>>>>>>>   
   >>>>>>>>>>> And what you say about writing to the tape of their UTM   
   >>>>>>>>>>> simply isn't possible. I don't think you really understand   
   >>>>>>>>>>> how UTMs work well enough to contemplate how to implement   
   >>>>>>>>>>> things in them.   
   >>>>>>>>>>>   
   >>>>>>>>>>> Your HHH takes a description of a D which it them simulates,   
   >>>>>>>>>>> but D is a *Turing Machine*. That means it must be able to   
   >>>>>>>>>>> run on its own, not just inside a UTM.   
   >>>>>>>>>>   
   >>>>>>>>>> DD() can run on its own, yet when it does   
   >>>>>>>>>> run on its own its liar paradox like structure   
   >>>>>>>>>> ceases to exist giving it different behavior.   
   >>>>>>>>>   
   >>>>>>>>> No. This is just your doublespeak. A given Turing Machine will   
   >>>>>>>>> have identical behaviour for identical inputs regardless of   
   >>>>>>>>> whether it is executed directly or run inside a UTM.   
   >>>>>>>>>   
   >>>>>>>>   
   >>>>>>>> Not when it fucking calls the same fucking UTM   
   >>>>>>>> that simulates it. Why the fuck won't you   
   >>>>>>>> fucking pay attention to this fucking difference?   
   >>>>>>>   
   >>>>>>> I have been paying attention and have seen you make this   
   >>>>>>> assertion many times, but it is simply wrong. In fact, I would   
   >>>>>>> say that it is axiomatically wrong. Cussing won't magically make   
   >>>>>>> it correct.   
   >>>>>>>   
   >>>>>>> André   
   >>>>>>>   
   >>>>>>   
   >>>>>> int Simulate(ptr x)   
   >>>>>> {   
   >>>>>>    x();   
   >>>>>>    return 1;   
   >>>>>> }   
   >>>>>   
   >>>>> Why would you name that function “Simulate"? It doesn't simulate   
   >>>>> anything. It simply calls the function passed to it.   
   >>>>>   
   >>>>>> int DD()   
   >>>>>> {   
   >>>>>>    int Halt_Status = Simulate(DD);   
   >>>>>>    if (Halt_Status)   
   >>>>>>      HERE: goto HERE;   
   >>>>>>    return Halt_Status;   
   >>>>>> }   
   >>>>>>   
   >>>>>> Do you understand that this DD will never stop running?   
   >>>>>   
   >>>>> Yes. But that DD has nothing to do with the D in the Linz Proof.   
   >>>>>   
   >>>>> André   
   >>>>>   
   >>>>   
   >>>> Do you want to go through two proofs side-by-side?   
   >>>> If you insist that the DD proof must always exactly   
   >>>> correspond to the Linz proof then we can go through   
   >>>> two proofs side-by-side.   
   >>>   
   >>> No. I am claiming that the above DD (please call it DD_UTM or some   
   >>> such to distinguish it from DD) has nothing to do with the diagonal   
   >>> case, not that there is some substantive difference between Linz's   
   >>> version and yours/   
   >>>   
   >>>> Because it seems to me that you contradicted yourself   
   >>>> in your other replies we are back to the last step where   
   >>>> you agreed.   
   >>>   
   >>> I already retracted the part of my post where I contradicted myself.   
   >>> I am having enough trouble trying to get you to move forward; I   
   >>> certainly have no intention of going *backwards*.   
   >>>   
   >>   
   >> I have been through this so many thousands of times that I   
   >> am only willing to go though this using the method that I   
   >> am using. I may not respond to anyone else on any other   
   >> subject until this one subject has mutual agreement.   
   >   
   > This "method" simply doesn't work and is therefore pointless. You're   
   > refusing to move forward until I agree to statements that I simply do   
   > not accept.   
      
   If you "do not accept" semantically equivalent sentences   
   there are only three possibilities:   
   (a) You do not understand the semantic equivalence.   
   (b) They not semantically equivalent.   
   (c) You and everyone else has been playing head games.   
      
   If you do not agree that a simulating termination   
   analyzer that never aborts and a pure simulation   
   of the same input are not equivalent then we seem   
   to have (c).   
      
   I could ask you to explain in precise detail how   
   the behavior of the input by a pure simulator   
   would differ from the behavior of this same input   
   by a simulating termination analyzer that never   
   aborts.   
      
   If you really are just playing head games you would   
   find some excuse to refuse.   
      
   > I gave my position in a recent post. Unless you have some   
   > substantive comments to make about that position (actual comments; not   
   > socratic questions) there is nothing left to discuss.   
   >   
   Socratic questioning is the only way to divide   
   an honest dialogue from just playing head games   
   so that everyone can see which is which.   
      
   --   
   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)