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

Am Sun, 28 Jul 2024 09:11:25 -0500 schrieb olcott:

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:

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:

It doesn't even get the answer correct.

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

Of course HHH can't abort its not-aborting simulation if you comment
that out. If left in, it can abort its aborting simulation - but it
doesn't need to.

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.

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.

No, it is not. HHH should see that HHH can abort.

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.

Only your HHH does have an (incorrectly unreachable) branch:
the one with if(Root).

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.