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

Op 27.jul.2024 om 21:27 schreef olcott:

On 7/27/2024 1:50 PM, Fred. Zwarts wrote:

Op 26.jul.2024 om 22:14 schreef olcott:

On 7/26/2024 2:46 PM, Mike Terry wrote:

On 26/07/2024 16:56, 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.

>
Well, the first two claims are literally untrue - outer HHH effectively uses the static mutable data to pass flags to the inner HHH that modify its behaviour.  The Root flag below is derived from the actual static data and causes inner HHH to totally skip its own abort logic!
>
You seem to acknowledge this, but claim it does not matter for various reasons, because whatever mistakes you are making, what finally gets printed out is saying the right thing!
>

>
If HHH gets the correct answer in an impure way then it only
counts that it gets it in an impure way if it is impossible
to get in a pure way. This makes it possible for HHH to get
this answer in a pure way:
>
Message-ID: <rLmcnQQ3-N_tvH_4nZ2dnZfqnPGdnZ2d@brightview.co.uk>
On 3/1/2024 12:41 PM, Mike Terry wrote:
 >
 > Obviously a simulator has access to the internal state
 > (tape contents etc.) of the simulated machine. No problem there.
>

>
Mike Terry is right that a simulator has access to the internal state of the simulated machine, but he did not say that it is correct to *change in this way* the state of the simulated machine.
Changing the state of the simulated machine is cheating.

 I know this and agree with him on this.
 

Of course a simulator can modify the input before of during the simulation.

 No that is cheating too.

That is exactly what you do when you change the value of the variable 'Root'. 'Root' is a hidden input for HHH.

 

It can change instructions, it can change the value of variable (such as Root).
However, it is clear that when it simulates a modified input, it is no longer simulating its input.
This is what happens when the simulator changes the value of Root. It changes the (hidden) input of the simulated machine, so that the simulator does no longer simulate the input, but something else.
>

 It is a verified fact that HHH get the correct halt
status decision in that HHH exactly matched that same
behavior pattern as this:
 void Infinite_Recursion()
{
   Infinite_Recursion();
}
 _Infinite_Recursion()
[0000215a] 55         push ebp
[0000215b] 8bec       mov ebp,esp
[0000215d] e8f8ffffff call 0000215a ; recursive call
[00002162] 5d         pop ebp
[00002163] c3         ret
Size in bytes:(0010) [00002163]
 Begin Local Halt Decider Simulation   Execution Trace Stored at:113934
Decide_Halting_HH:1
[0000215a][00113924][00113928] 55         push ebp
[0000215b][00113924][00113928] 8bec       mov ebp,esp
[0000215d][00113920][00002162] e8f8ffffff call 0000215a
[0000215a][0011391c][00113924] 55         push ebp
[0000215b][0011391c][00113924] 8bec       mov ebp,esp
[0000215d][00113918][00002162] e8f8ffffff call 0000215a
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
 

Incorrect.
It is a verified fact that HHH gets the incorrect halt status decision in that HHH is unable to simulate the behaviour pattern that is also seen in:
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
It decides after N recursions that there is an infinite recursion, which is incorrect.
Your dreams of an infinite recursion are no evidence and it contradicts that HHH halts after it aborts after two simulation cycles.
The reason that HHH gets the incorrect halting status is related to the verified fact that
HHH cannot possibly simulate *itself* correctly.
When it aborts, the simulated HHH is only one cycle away from its own abort.
Dreaming of a HHH that does not abort does not change the fact that we are considering a HHH that *does* abort and halt.
Now you are making it even worse by showing that your HHH uses a variable 'Root' to cheat the simulation.