Re: DDD incorrectly emulated by HHH is INCorrectly rejected as non-halting V2

On 7/16/24 11:57 AM, olcott wrote:

On 7/16/2024 2:20 AM, Mikko wrote:

On 2024-07-15 12:22:19 +0000, olcott said:
>

On 7/15/2024 3:49 AM, joes wrote:

Am Sun, 14 Jul 2024 19:30:27 -0500 schrieb olcott:

On 7/14/2024 7:20 PM, joes wrote:

Am Sun, 14 Jul 2024 09:00:55 -0500 schrieb olcott:

On 7/14/2024 3:29 AM, joes wrote:

Am Sat, 13 Jul 2024 18:33:53 -0500 schrieb olcott:

On 7/13/2024 6:26 PM, joes wrote:

Can you elaborate? All runtime instances share the same static
code.
I am talking about the inner HHH which is called by the simulated
DDD. That one is, according to you, aborted. Which is wrong,
because by virtue of running the same code, the inner HHH aborts
ITS simulation of DDD calling another HHH.

What are the twins and what is their difference? Do you disagree with
my tracing?

>

The directly executed DDD is like the first call of infinite
recursion. The emulated DDD is just like the second call of infinite
recursion. When the second call of infinite recursion is aborted then
the first call halts.

Not really. Execution does not continue.

>

void Infinite_Recursion()
{
Infinite_Recursion();
}
The above *is* infinite recursion.
A program could emulate the above code and simply skip line 3 causing
Infinite_Recursion() to halt.

That would be incorrect.

>

When DDD calls HHH(DDD) HHH returns.

Therefore it does not need to be aborted.

>

When DDD correctly emulated by HHH the call never returns as is proven
below. The executed DDD() has HHH(DDD) skip this call.

I do not see this below.

>

HHH(DDD) must skip this call itself by terminating the whole DDD
process.

>

Because this HHH does not know its own machine address HHH only sees
that DDD calls a function that causes its first four steps to be
repeated. HHH does not know that this is recursive simulation. To HHH
it looks just like infinite recursion.

>

New slave_stack at:1038c4 -- create new process context for 1st DDD
Begin Local Halt Decider Simulation   Execution Trace Stored at:1138cc

>

[0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call
HHH(DDD) New slave_stack at:14e2ec -- create new process context for
2nd DDD

>

[0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call
HHH(DDD) Local Halt Decider: Infinite Recursion Detected Simulation
Stopped

How is this detected? Is it also triggered when calling a function in a
loop?

>

You never bothered to answer whether or not you have 100% understanding
of infinite recursion. If you don't then you can never understand what I
am saying. If you do that I already proved my point. Here is the proof
again:

As if you would believe me.
You never bothered to answer my questions (see above).
That only proves that HHH and DDD halt.
>

>
This *is* an answer too difficult for you to understand.
>
New slave_stack at:1038c4
Begin Local Halt Decider Simulation   Execution Trace Stored at:1138cc
[00002172][001138bc][001138c0] 55         push ebp      ; housekeeping
[00002173][001138bc][001138c0] 8bec       mov ebp,esp   ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55         push ebp      ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec       mov ebp,esp   ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

>
The trace does not show that HHH returns so there is no basis to
think that HHH is a decider.
>

 The trace shows the data of the executed program of HHH that
does halt. I will have to put the whole thing into a PDF.

Excpet that it is INCORRECT because a call instruction, needs to be followed by the emulation of the instruction at the destination of the call.
The fact that you STILL don't understand this, just shows that you seem to be INCAPABLE of understanding about how computers actually work.
That, or you are just a pathological liar that doesn't care about truth.

 Most of what you need to see is on the last page.
The x86 source-code of DDD, main() and the full
execution trace of DDD emulated by HHH and DDD
emulated by the emulated HHH are on this page.
https://liarparadox.org/HHH(DDD)_Trace.pdf // 38 pages

Which isn't a correct emulation of DDD by HHH.
So, you are just ADMITTING that you are just a LIAR.

 This shows the full execution trace yet is much
more difficult to see the execution trace of DDD emulated by HHH
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf // 196 pages
I will update it to highlight machine code lines of DDD in yellow
 

No it isn't, and what you are showing is just a LIE.