Path: news.eternal-september.org!eternal-september.org!.POSTED!not-for-mail
From: olcott <polcott333@gmail.com>
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
Subject: Re: How do simulating termination analyzers work? (V2)
Date: Sat, 21 Jun 2025 10:26:00 -0500
Organization: A noiseless patient Spider
Lines: 322
Message-ID: <1036iua$14sj8$1@dont-email.me>
References: <1034bjk$6kj0$2@dont-email.me>
 <46077c7cead1d86f5f8c15d01c8f186d1c080515@i2pn2.org>
 <1034va2$bdkk$1@dont-email.me> <Hvx5Q.1274563$lZjd.1163517@fx05.ams4>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 21 Jun 2025 17:26:03 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="c33a34d5810729869e79acc5a916ae39";
	logging-data="1208936"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1/w6Hq6aMNXlB/pbrEv3mVp"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:dcsUeMWuDChWAh3zmBnKSfJdNfo=
X-Antivirus-Status: Clean
X-Antivirus: Norton (VPS 250621-4, 6/21/2025), Outbound message
Content-Language: en-US
In-Reply-To: <Hvx5Q.1274563$lZjd.1163517@fx05.ams4>

On 6/21/2025 7:24 AM, Mr Flibble wrote:
> On Fri, 20 Jun 2025 19:44:50 -0500, olcott wrote:
> 
>> On 6/20/2025 7:01 PM, Richard Damon wrote:
>>> On 6/20/25 3:08 PM, olcott wrote:
>>>> void Infinite_Recursion()
>>>> {
>>>>     Infinite_Recursion(); return;
>>>> }
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>>     HERE: goto HERE;
>>>>     return;
>>>> }
>>>>
>>>> void DDD()
>>>> {
>>>>     HHH(DDD);
>>>>     return;
>>>> }
>>>>
>>>> int Sipser_D()
>>>> {
>>>>     if (HHH(Sipser_D) == 1)
>>>>       return 0;
>>>>     return 1;
>>>> }
>>>>
>>>> int DD()
>>>> {
>>>>     int Halt_Status = HHH(DD);
>>>>     if (Halt_Status)
>>>>       HERE: goto HERE;
>>>>     return Halt_Status;
>>>> }
>>>>
>>>> My claim is that each of the above functions correctly simulated by
>>>> any termination analyzer HHH that can possibly exist will never stop
>>>> running unless aborted by HHH.
>>>
>>> The problem is that NO "Simulating Halt Decider" HHH, can correctly
>>> simulte ANY of those inputs.
>>>
>>> For the first two, it is possible for a smart enough Simulation Halt
>>> Decider to determine that the correct simulation of the input will not
>>> halt, no matter what HHH actually does, since it doesn't depend on the
>>> decider.
>>>
>>> For the last 3, it can not prove that they will not halt, as, in fact,
>>
>>> the correct simulation of all those inputs *WILL* halt
>>
>> _DDD()
>> [00002192] 55             push ebp [00002193] 8bec           mov ebp,esp
>> [00002195] 6892210000     push 00002192 [0000219a] e833f4ffff     call
>> 000015d2  // call HHH [0000219f] 83c404         add esp,+04 [000021a2]
>> 5d             pop ebp [000021a3] c3             ret Size in
>> bytes:(0018) [000021a3]
>>
>> Exactly how would N instructions of DDD emulated by HHH according to the
>> semantics of the x86 language reach machine address 000021a3 ?
> 
> This exchange between **Peter Olcott** and **Richard Damon** is a clash
> over the semantics of simulation, halting behavior, and what it means to
> *correctly analyze* a self-referential or looping function using a
> theoretical "termination analyzer" (`HHH`).
> 

HHH emulates N x86 machine language instructions of
DDD according to the semantics of the x86 language,
thus necessarily emulates these N instructions correctly.
This also requires HHH to emulate itself emulating DDD
at least once.

The main computer science definition of halting is
reaching a final halt state, anyone disagreeing is
incorrect. An alternative definition that is easier
for programmers to understand is never stop running.
Any disagreement with this is incorrect.

When there are no N instructions of DDD correctly
simulated by HHH that can possibly reach their final
halt state then it is a verified fact that the input to
HHH(DDD) specifies a non-halting sequence of
configurations.

> Let’s break this down across three layers: **technical validity**,
> **semantic precision**, and **communication clarity**.
> 
> ---
> 
> ## 🔍 1. **Olcott's Argument**
> 
> Olcott gives a series of functions that are meant to illustrate programs
> that either:
> 
> * Loop infinitely in a trivially detectable way (`Infinite_Loop`,
> `Infinite_Recursion`), or
> * Engage in **self-referential calls to the analyzer** (`HHH`) to simulate
> undecidable or paradoxical behavior (`DDD`, `Sipser_D`, `DD`).
> 
> He claims:
> 
>> Any HHH that correctly simulates these programs will never stop running
> unless it *aborts* the simulation, because these programs themselves never
> halt (or have undecidable behavior).
> 

That is incorrect. My actual claim is that these
inputs to HHH specify non halting behavior. The
directly executed DDD() is the caller of HHH(DDD)
thus not its input.

> Then he posts **x86 machine code** for `DDD()` and asks:
> 
>> How could a simulator (HHH) ever emulate this code to the final `ret`
> instruction at address `000021a3`, given the semantics?
> 
> ---
> 
> ### ✅ Valid Point (in Narrow Scope)
> 
> Olcott is **correct** in a narrow sense:
> If you define "correct simulation" as **faithfully executing each
> instruction step-by-step**, then **simulating an infinite loop** or a
> recursive self-reference will indeed run forever. 

It is not any narrow sense.

> Thus, **any system that halts** to declare "this never halts" *must not be
> simulating it fully*, but analyzing it another way.
> 
> This point is **semantically sound**, **but trivially true**. And it's
> already well-acknowledged in computability theory.
> 

*This is not true*
The input to HHH1(DDD) halts and the input to HHH(DDD)
does not halt because these inputs specify a different
sequence of steps.

Because DDD calls HHH(DDD) this sequence includes HHH
emulating itself emulating DDD.

Because DDD does not call HHH1 then HHH1 never emulates
itself emulating DDD.

*ChatGPT Analyzes Simulating Termination Analyzer*
https://www.researchgate.net/publication/385090708_ChatGPT_Analyzes_Simulating_Termination_Analyzer 


At the end of this paper is a link to a live ChatGPT
session that understands how and why I am correct about
HHH(DDD). When people try to point out any mistake in
this work ChatGPT explains (in its own words) how and
why they are wrong.

> ---
> 
> ## 🔍 2. **Damon’s Response**
> 
> Damon replies:
> 
>> The last three examples (e.g., `DDD`, `Sipser_D`, `DD`) **do halt** in
> practice.
>> Therefore, any simulation that models their behavior *correctly* would
> **eventually halt**.
> 
> This is a **concrete rebuttal** of Olcott’s claim that they *must* never
> halt unless the simulation is aborted.
> 
> Damon is pointing out that:
> 
> * `DDD()` halts *if* `HHH(DDD)` halts.

========== REMAINDER OF ARTICLE TRUNCATED ==========