XPost: comp.theory, sci.math   
   From: chris.m.thomasson.1@gmail.com   
      
   On 12/16/2025 4:04 AM, Richard Damon wrote:   
   > On 12/16/25 1:40 AM, dart200 wrote:   
   >> On 12/15/25 12:42 PM, olcott wrote:   
   >>> I totally understand what you mean by context aware.   
   >>> The behavior that the input to HHH(DD) specifies   
   >>> is different than the behavior that the input to   
   >>> HHH1(DD) specifies because DD only calls HHH(DD)   
   >>> in recursive simulation.   
   >>   
   >> no context-aware would mean that HHH(DD) returns differently based on   
   >> the specific location of the runtime instance   
   >>   
   >   
   > But since the QUESTION isn't context aware, any change of answer means   
   > it is wrong.   
   >   
   > If HHH(DD) is supposed to ask about the behavior of DD when it is run,   
   > and that doesn't depend on that context you do that, then the answer   
   > can't change and still be correct.   
   >   
   > Deciders aren't allowed to only be correct in only some instances.   
   >   
      
   Olcott cherry picks a hyper simple program and says see, I can tell if   
   it halts or not! I am an genius. Ect... He can detect a non-terminating   
   condition! God be praised indeed.   
      
   If HHH(DD) returns non-zero it goes into an infinite GOTO loop. We can   
   say this is non-halting. If HHH(DD) returns zero, DD halts.   
      
   int DD()   
   {   
   10:    int Halt_Status = HHH(DD);   
   20:    if (Halt_Status)   
   30:       HERE: goto HERE;   
   40:    return Halt_Status;   
   }   
      
   Using static analysis. Line 30 goes into an infinite loop. 99.(9)% sure!   
      
   So, lets reinstrument it:   
      
   global unsigned long pc_DD_0 = 0; // infinite goto HERE: goto HERE;   
   global unsigned long pc_DD_1 = 0; // halt path   
   global unsigned long pf_DD_0 = 0; // fuzzer   
      
   int DD_reinstrument()   
   {   
   10:    int Halt_Status = HHH(DD); // we can omit this.   
   15:    Halt_Status = pf_DD_0; // fuzzer   
   20:    if (Halt_Status) {   
   25:       atomic_inc(&pc_DD_0); // hit the infinite goto path.   
   26:       return Halt_Status; // or we can let it spin...   
   30:       HERE: goto HERE; }   
   35:    atomic_inc(&pc_DD_1); // halt   
   40:    return Halt_Status;   
   }   
      
   We mock up a HHH(DD) and fuzz it with all legal values for an int.   
   HHH(DD) is hijacked and receiving fizzed data. This is legal I think   
   because HHH(DD) returns an int, well, lets set that int to a bunch of   
   random shit. lol. The fuzzer can be random or monotonic incs all in one.   
      
   Now, something else, another thread can monitor those path counters   
   (pc_DD_0, pc_DD_1, ...) When they all are non-zero, we got an all paths   
   traveled scenario for DD_reinstrument?()   
      
   We can say it halts or does not halt depending on the return value from   
   HHH(DD). We simulated all paths as in pc_DD_0 and pc_DD_1 are non-zero.   
      
      
   For the per path counters, we want to say okay they were hit, and we   
   need a count, but still always show that they were hit. Think of a   
   counter rolloing over back to 0. Uggg. Therefore, this atomic algo might   
   work for a per-path counter:   
      
   p = fetch_add(counter, 0x2);   
   if (p == 0) fetch_or(counter, 0x1);   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)