Re: This function proves that only the outermost HHH examines the execution trace

The problem you keep on ignoring is that the behavior of a program is what it does when actually run, and not partially simulated and then aborted.
That fundamental error in you definitions means none of you logic matters.
The fact that DDD calls an HHH(DDD) that will, when called by main the same way, returns to main, means it will return to DDD and thus DDD halts.
Your argument contrary to that just proves you don't understand that emulation is only a means to observe behavior, and doesn't actually define that behavior, especially when it is just a partial emulation.
Fundamentally, you are just proving you are just incapable of understand the difference between the TRUTH of the behavior of DDD, which is established purely by the actual behavor of it code, which neds ALL the code (incuding that of HHH)
That behavior is fully fixed and determined the moment that code is defined. We only know that behavior by running or emulating that code, FULLY.
If HHH returns to main, and is an actual computation, then it returns to DDD and thus DDD WILL HALT. PERIOD.
To claim anything else is to admit that you are a liar or your logic system is just inconsistant, or both.
On 7/26/24 11:56 AM, olcott wrote:

This is meant for Mike, Joes and Fred don't have the technical competence to understand it.
 Richard might be able to understand it yet the fact that he is
stuck in rebuttal mode makes any understanding that he may have
utterly useless.
 Mike: It seems that HHH has been a pure function of its inputs
and never has provided data downward to its slaves that corrupts
their halt status decision. They don't even make a halt status
decision thus cannot make a corrupted one.
 I could change the code so that the slave instances can and do
try to form a halt status decision on the basis of the execution
trace that they do have.
 There is no sense in doing that because they can't possibly have
enough data, they will always be one whole execution trace behind
the next outer instance of HHH.
 As they are the slaves perform their proper function of showing
the actual behavior of DDD correctly emulated by HHH.
 u32 Decide_Halting_HH(u32**                   Aborted,
                       u32**                   execution_trace,
                       Decoded_Line_Of_Code**  decoded,
                       u32                     code_end,
                       u32                     End_Of_Code,
                       Registers**             master_state,
                       Registers**             slave_state,
                       u32**                   slave_stack,
                       u32                     Root)
{
   u32 aborted_temp = 0;  // 2024-06-05
   u32 Current_Length_Of_Execution_Trace = 0;
   while (aborted_temp == 0) // 2024-06-05
   {
     u32 EIP = (*slave_state)->EIP; // Save EIP of this instruction
     DebugStep(*master_state, *slave_state, *decoded); // Execute it
     if (EIP > Last_Address_Of_Operating_System())     // Ignore OS code
     {
       PushBack(**execution_trace, (u32)*decoded,
                sizeof(Decoded_Line_Of_Code));
     }
      if (EIP == code_end)
       return 1;
      if (Root)  // Master UTM halt decider
     {
       u32* address = (u32*)**execution_trace;
       u32 size  = (u32)*(address-1);
       // Detects slave appended an instruction to its execution_trace
       if (size > Current_Length_Of_Execution_Trace)
       {
         Current_Length_Of_Execution_Trace = size;
         aborted_temp =     // 2024-06-05
         Needs_To_Be_Aborted_HH
         ((Decoded_Line_Of_Code*)**execution_trace);
       }
     }
   }
   if (aborted_temp == 1) // 2021-01-26 Must be aborted
     return 0;
   return 1;           // 2021-01-26 Need not be aborted
}