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

Op 01.aug.2024 om 23:00 schreef olcott:

On 8/1/2024 2:26 PM, Fred. Zwarts wrote:

Op 01.aug.2024 om 18:00 schreef olcott:

On 8/1/2024 10:46 AM, joes wrote:

Am Thu, 01 Aug 2024 07:56:27 -0500 schrieb olcott:

On 8/1/2024 7:52 AM, Fred. Zwarts wrote:

Op 01.aug.2024 om 14:03 schreef olcott:

On 8/1/2024 2:52 AM, Mikko wrote:

On 2024-07-31 17:33:38 +0000, olcott said:

On 7/31/2024 4:15 AM, Mikko wrote:

On 2024-07-30 23:40:21 +0000, olcott said:

On 7/30/2024 2:00 AM, Mikko wrote:

On 2024-07-29 16:50:53 +0000, olcott said:

On 7/28/2024 3:59 AM, Mikko wrote:

On 2024-07-27 20:05:31 +0000, olcott said:

>

When instructions are executed/emulated according to the semantics of
the x86 language then they are executed/emulated correctly.
>

But only those instructions. A halting program is simulated correctly
if no instructions are skipped.

>
Correctly and completely are not the same damn thing you
freaking moron.

Yes, an incomplete simulation is also incorrect.
>

>
When N steps of DDD are emulated correctly one can only
say that N steps were not emulated correctly when one
is a liar.

>
Nobody claims it. It is just your dream.
When the last M steps of a halting DDD are skipped, one can only say that it is a correct simulation when one is a liar.
This is the reality.
>

>
When a correct and complete emulation is impossible
because the computation has no end then it is pretty
damn stupid to insist an a complete emulation.
>

>
Nobody claims it. It is just your dream.
When a correct and complete simulation of HHH by itself is not possible even when HHH halts, then it is pretty stupid to insist that a correct simulation of halting program shows that it does not halt.
That is the reality.
>
Dreams are no substitute for fact, not for logic.
>

 There are no last steps of DDD correctly emulated by HHH.

Yes, that is your dream. No evidence presented.

There are N steps of DDD correctly emulated by HHH that
prove there are no last steps of DDD correctly emulated
by HHH. This is essentially mathematical induction.

This is the real evidence:
HHH is simulating *itself*. HHH is coded to abort after two cycles.
When HHH aborts after two cycles, the simulated HHH has one cycle to go.
After that last cycle HHH returns to DDD and DDD halts.
So, there are last steps of DDD, when correctly simulated.
This is shown by the correct simulation by HHH1.
But olcott keeps dreaming.
Dreams are no substitute for facts, not for logic.
DDD is a misleading and unneeded complication. It is easy to eliminate DDD:
        int main() {
          return HHH(main);
        }
This has the same problem. This proves that the problem is not in DDD, but in HHH, which halts when it aborts the simulation, but it decides that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.
HHH is simply unable to decide about comparable finite recursions.