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

On 7/28/24 10:11 AM, olcott wrote:

On 7/28/2024 2:50 AM, Fred. Zwarts wrote:

Op 27.jul.2024 om 22:05 schreef olcott:

On 7/27/2024 2:55 PM, Fred. Zwarts wrote:

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.

>
If you had sufficient understanding of the x86 language
you would know that DDD is correctly emulated by HHH.

>
If you understood only a little bit of x86, you would know that changing the value of a variable (like Root), will modify the behaviour of a program, making a cheating simulator.
>

 I have been programming in the x86 language since it was new.
 

And thus you should know that a call instruction goes to the subroutine called, and the execution continues there, and unless you look at what that routine ACTUALLY does, you don't know what your code does.
That subroutine HHH is PART of the program DDD, and thus DDDs behavior is a function of it, so you can't look at the behavior of one version of DDD that uses one version of HHH to figure out what a DIFFERENT version of DDD that uses a DIFFERENT version of HHH does.

I commented the whole block of code out that does the abort
so that HHH is just a simulator and not a termination analyzer
and it just keeps on running until the instruction limited of
50,000,000 instructions have been emulated. Every recursive
emulation take about 100-fold more steps than the prior one.
 

But that just shows that you ignore the fundamental property of programs, that you need to look at the code of the program you are deciding on, not something else.
I seem to remember you calling people who looked at something that wasn't the ACTUAL input just damned liars.
If the input describing DDD doesn'tr include HHH, then it isn't a program and you are just a liar that you are giving it a proper input.
Since HHH seems to know something of the HHH that DDD calls, it must be part of the specification of the input, and thus it that HHH doesn't do exactly per that specification, you are just that damned liar you were talking about.
And One HHH that never aborts and the other HHH that do abort can not BOTH be a correct implementation of a full specification of what HHH is/does, so that again makes you that damned liar.

_DDD()
[00002137] 55               push ebp
[00002138] 8bec             mov ebp,esp
[0000213a] 6837210000       push 00002137
[0000213f] e853f4ffff       call 00001597
[00002144] 83c404           add esp,+04
[00002147] 5d               pop ebp
[00002148] c3               ret
Size in bytes:(0018) [00002148]
 _main()
[00002157] 55               push ebp
[00002158] 8bec             mov ebp,esp
[0000215a] e8d8ffffff       call 00002137
[0000215f] 33c0             xor eax,eax
[00002161] 5d               pop ebp
[00002162] c3               ret
Size in bytes:(0012) [00002162]
   machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002157][0010379f][00000000] 55               push ebp
[00002158][0010379f][00000000] 8bec             mov ebp,esp
[0000215a][0010379b][0000215f] e8d8ffffff       call 00002137
[00002137][00103797][0010379f] 55               push ebp
[00002138][00103797][0010379f] 8bec             mov ebp,esp
[0000213a][00103793][00002137] 6837210000       push 00002137
[0000213f][0010378f][00002144] e853f4ffff       call 00001597
New slave_stack at:103843
 Begin Local Halt Decider Simulation   Execution Trace Stored at:11384b
[00002137][0011383b][0011383f] 55               push ebp
[00002138][0011383b][0011383f] 8bec             mov ebp,esp
[0000213a][00113837][00002137] 6837210000       push 00002137
[0000213f][00113833][00002144] e853f4ffff       call 00001597
New slave_stack at:14e26b
[00002137][0015e263][0015e267] 55               push ebp
[00002138][0015e263][0015e267] 8bec             mov ebp,esp
[0000213a][0015e25f][00002137] 6837210000       push 00002137
[0000213f][0015e25b][00002144] e853f4ffff       call 00001597
New slave_stack at:15e30b
[00002137][0016e303][0016e307] 55               push ebp
[00002138][0016e303][0016e307] 8bec             mov ebp,esp
[0000213a][0016e2ff][00002137] 6837210000       push 00002137
[0000213f][0016e2fb][00002144] e853f4ffff       call 00001597
New slave_stack at:16e3ab
[00002137][0017e3a3][0017e3a7] 55               push ebp
[00002138][0017e3a3][0017e3a7] 8bec             mov ebp,esp
[0000213a][0017e39f][00002137] 6837210000       push 00002137
[0000213f][0017e39b][00002144] e853f4ffff       call 00001597
New slave_stack at:17e44b
[00002137][0018e443][0018e447] 55               push ebp
Number of Instructions Executed(50000000) == 746269 Pages
  

>
That you don't know this conclusively proves that you
don't have sufficient understanding of the x86 language.

>
Irrelevant nonsense ignored.
>

>
All of the issues that Mike bought up have nothing to
do with correct emulation. They only pertain to how
the halt status decision is derived.

>
So, why do you bring up x86?
>
But you keep talking about a halt status. E.g. that the simulator must abort to halt a non-halting program.
You are twisting the meaning of simulator often, as you think that aborting is part of a simulation.
You seem to think that aborting is part of the semantics of the x86 language.
>

>
That the halt status decision is proven to be correct
on the basis that its behavior pattern exactly matches
this infinite recursion behavior pattern is proven.
>
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
[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
>

>
Proof by example fails.
>
That the simulation is incorrect is because HHH (and apparently its programmer) think that a two level recursion is an infinite recursion.
HHH is simply unable to decide about comparable finite recursions.
>
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.
>

 HHH(Infinite_Recursion) sees the non-halting pattern below.
This *is* the exact same pattern that HHH(DDD) sees.

Nope. because a call to Infinte_Recursion() is not the same as a call to HHH(DDD), since the later WILL abort its simulation and return, while the former is unable to do anything like it.
So, You are just demonstrating that you are nothing but a pathetic ignorant pathological lying idiot that doesn't care about truth due t your reckless disregard for it.

 void Infinite_Recursion()
{
   Infinite_Recursion();
}
 _Infinite_Recursion()
[0000215a] 55         push ebp      ; 1st line
[0000215b] 8bec       mov ebp,esp   ; 2nd line
[0000215d] e8f8ffffff call 0000215a ; 3rd line
[00002162] 5d         pop ebp
[00002163] c3         ret
Size in bytes:(0010) [00002163]
 Begin Local Halt Decider Simulation   Execution Trace Stored at:113934
[0000215a][00113924][00113928] 55         push ebp      ; 1st line
[0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line
[0000215a][0011391c][00113924] 55         push ebp      ; 1st line
[0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
 If you cannot see that the above x86 machine code proves that
it will never halt then you can't possibly understand what I
have been saying.
 The first three lines of _Infinite_Recursion() repeat and there
are no conditional branch in that sequence that can possibly keep
it from repeating forever.
 

Right, but there *IS* in a correct emulation of a call HHH(DDD) either seeing it in the instructions of HHH, or in the definition of HHH as a DECIDER that may choose to abort it's emulation to return the answer of "non-halting".
The fact that if it does so, it makes itself wrong, just shows why the problem in non-computable.