Path: nntp.eternal-september.org!news.eternal-september.org!eternal-september.org!feeder3.eternal-september.org!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory,sci.logic
Subject: Re: How do simulating termination analyzers work? ---Truth Maker
 Maximalism FULL_TRACE
Date: Thu, 17 Jul 2025 19:19:03 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <283eca361da31233f55d1ed459f683d536a5bfb7@i2pn2.org>
References: <102sjg5$2k3e9$1@dont-email.me> <104e164$2852a$1@dont-email.me>
 <104e6nd$12ua$1@news.muc.de> <104e93k$29rpg$1@dont-email.me>
 <104ed4k$223c$1@news.muc.de> <104ehua$2c91h$1@dont-email.me>
 <104epfu$nqi$1@news.muc.de> <104fdma$2n8gq$1@dont-email.me>
 <104gkad$2f8e$1@news.muc.de> <10515pj$2v547$1@dont-email.me>
 <c1fa8b9a19b4a102d7f5c2d58cf4b9b127c30955@i2pn2.org>
 <1051r18$36s16$3@dont-email.me>
 <a6849743e4a6af25dc93b3b269e1d39002488efe@i2pn2.org>
 <105394s$3ev5b$15@dont-email.me>
 <f5a2ebe0935b2c891a06650e89c28fbcc0560f61@i2pn2.org>
 <1054he7$3s0eq$6@dont-email.me>
 <e510d4751825282a6858172b5e8516d1c1ec789a@i2pn2.org>
 <5erdQ.67036$r61e.50840@fx11.ams4>
 <b7541a89c5db2d0db513455cd7b83349544406ee@i2pn2.org>
 <1058fss$pn5l$3@dont-email.me>
 <49480dece30605ff692baac78083722e2a25b7cf@i2pn2.org>
 <1058hht$q07u$2@dont-email.me>
 <d659a8f6eca80516714ba11fd9512100c290c5fe@i2pn2.org>
 <1058onb$raqa$1@dont-email.me> <105ac8p$25t70$2@dont-email.me>
 <105aut4$1bk0p$4@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 17 Jul 2025 23:28:35 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1088484"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <105aut4$1bk0p$4@dont-email.me>

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