Re: DDD correctly emulated by HHH is Correctly rejected as non-halting V2

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.

If you have a 100% complete understanding infinite recursion then I can
explain it in terms of much more details, otherwise you can't possibly
understand.

What are the twins and what is their difference?
Please do explain.
Do you disagree with my tracing?
>

void DDD()
{
   HHH(DDD);
}
int main()
{
   DDD();
}
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.
void Infinite_Recursion()
{
   Infinite_Recursion();
}
_Infinite_Recursion()
[00002122] 55         push ebp
[00002123] 8bec       mov ebp,esp
[00002125] e8f8ffffff call 00002122
[0000212a] 5d         pop ebp
[0000212b] c3         ret
Size in bytes:(0010) [0000212b]
The above *is* infinite recursion.
A program could emulate the above code and simply
skip line 3 causing Infinite_Recursion() to halt.
When DDD calls HHH(DDD) HHH returns.
When DDD correctly emulated by HHH the call never returns as is
proven below. The executed DDD() has HHH(DDD) skip this call.
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
[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 -- create new process context for 2nd DDD
[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
Computable functions are the formalized analogue of the
intuitive notion of algorithms, in the sense that a
function is computable if there exists an algorithm that
can do the job of the function, i.e. given an input of the
function domain it can return the corresponding output. https://en.wikipedia.org/wiki/Computable_function
According to the theory of computation the DDD that calls
HHH(DDD) is not in the domain of HHH. HHH is not allowed
to report on the behavior of the process that it is contained
within. *That breaks the rules of computation theory* HHH
cannot even see the steps that were executed before it
was first invoked.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer