Path: ...!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: This function proves that only the outermost HHH examines the
 execution trace
Date: Fri, 26 Jul 2024 22:17:23 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <fa8edcaf947e240fe7895c4e3a89dcb52beb66a1@i2pn2.org>
References: <v80h07$2su8m$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 27 Jul 2024 02:17:23 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="485228"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <v80h07$2su8m$3@dont-email.me>
Content-Language: en-US
Bytes: 5406
Lines: 99

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
> }
> 
> 
>