Re: How do simulating termination analyzers work? ---Truth Maker Maximalism FULL_TRACE

On 7/17/25 9:47 AM, olcott wrote:

On 7/17/2025 3:29 AM, Fred. Zwarts wrote:

Op 16.jul.2025 om 19:49 schreef olcott:

>
_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]
>
Each element of the infinite set of functions
at machine address 000015d2 that emulates 0 to ∞
instructions of the above machine code never
reaches its emulated "ret" instruction final
halt state BECAUSE DDD CALLS EACH EMULATOR IN
RECURSIVE EMULATION.

 

And because HHH would simulate DDD in recursive simulation.
HHH cooperates with DDD to create a recursion. Without HHH starting a new simulation, there would not be a recursion.

The input to HHH(DDD) specifies recursive emulation.

*FINITELY* recursive emulation, since HHH is defined to be a decider.

 

This is already evidence that simulation is not the right tool to analyse the input.
>

 In other words you disagree that a simulation by a UTM
is a correct measure of behavior. (A simulation by a UTM
is defined to be a correct measure of behavior).
 

But the simulation of DDD by a UTM will halt, as the input given to that UTM will still call the HHH that aborts and returns 0, as that *IS* what HHH has been defined to do and is the HHH that DDD calls.
You are just proving you are just a pathological liar.

But HHH does abort. So, there is no infinite recursion. So, there is a final halt state. But the abort does not help to reach that final halt state. HHH still fails to reach it.

 _DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

Which, by itself, is just a category error, as the input to Halt Deciders need to be PROGRAMS, and thus need to include the code of the SPEIFIC HHH that it calls
It also needs to be part of "the input" or no simulator can simulate it.

 Each element of the infinite set of functions
at machine address 000015d2 that emulates 0 to ∞
instructions of the above machine code never
reaches its emulated "ret" instruction final
halt state BECAUSE DDD CALLS EACH EMULATOR IN
RECURSIVE EMULATION.

But EVERY one of the ones that call an HHH that returns 0, *WILL* Halt when simulated by a UTM, and NONE of those HHH did a correct simulation.
Thus, you just committed an infinite number of LIES.

 *ChatGPT agrees and provides the reasoning why it agrees*
https://chatgpt.com/share/6877f09c-7b18-8011-b075-ea3671e57886

Becausee you LIE to it too.

 

This illustrates that simulation is not the right tool for this input.

 Disagreeing with the definition of a UTM is incorrect.

Right, as is forgetting the defintion of a program.
Not even a UTM could correctly simulate your above input, as it will FAULT when it reaches the Call HHH as you are trying to define that to not be part of the input.
But all that does is prove that you whole arguement is based on self-contradictions by lies.

 

Each element in the infinite set fails to reach the final halt state.

 Because it remains stuck in recursive emulation.

No, they all hit UNDEFIEND BEHAIVOR (and thus "crash") because the y access memory that isn't part of the input.
Or they prove that you LIED about what was the input.
Your world is just in error.
You claim BOTH that "the input" doesn't contain the code of HHH, so they are all the same, and that it also allows that HHH has it as part of its input so it can simulate it as part of the input.
I guess you just proved you are just a big fat liar.

 void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}
 Infinite_Recursion() correctly simulated bu HHH also
cannot possibly reach its own simulated "return"
statement final halt state. Not possibly reaching
final halt state is the correct measure on non-halting
for both HHH(Infinite_Recursion) and HHH(DDD).

Right, but that isn't DDD.
Sorry, you are just proving your stupidity.

 

There is a final halt state for each of them, but the all fail to reach it. (Of course the very different HHH that does not abort at all, has no final halt state, so it fails as well.)