Path: news.eternal-september.org!eternal-september.org!.POSTED!not-for-mail
From: olcott <polcott333@gmail.com>
Newsgroups: comp.theory,sci.logic
Subject: Re: How do simulating termination analyzers work? ---Truth Maker
 Maximalism FULL_TRACE
Date: Mon, 7 Jul 2025 09:42:10 -0500
Organization: A noiseless patient Spider
Lines: 282
Message-ID: <104gmc2$2uc68$6@dont-email.me>
References: <102sjg5$2k3e9$1@dont-email.me>
 <66c00d5703907e846f537310dfb201485e1b7b2a@i2pn2.org>
 <10492eb$u8g5$1@dont-email.me> <104b5l9$fnl$1@news.muc.de>
 <104ben3$1hqln$1@dont-email.me> <104bt5h$1l1g$1@news.muc.de>
 <104bunk$1kcb5$1@dont-email.me> <104did7$hlh$1@news.muc.de>
 <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>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 07 Jul 2025 16:42:11 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="5b8546c5fedfaaedc96332a808ca8671";
	logging-data="3092680"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX19MxKmyxGGhFeVPYqKO6V0e"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:dphKLmeWG3zCKO56Sg3M/tGpX2E=
X-Antivirus-Status: Clean
In-Reply-To: <104gkad$2f8e$1@news.muc.de>
Content-Language: en-US
X-Antivirus: Norton (VPS 250707-2, 7/7/2025), Outbound message

On 7/7/2025 9:07 AM, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>> On 7/6/2025 4:23 PM, Alan Mackenzie wrote:
>>> olcott <polcott333@gmail.com> wrote:
>>>> On 7/6/2025 12:52 PM, Alan Mackenzie wrote:
>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>> On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
> 
>>> [ .... ]
> 
>>>>>> int DD()
>>>>>> {
>>>>>>      int Halt_Status = HHH(DD);
>>>>>>      if (Halt_Status)
>>>>>>        HERE: goto HERE;
>>>>>>      return Halt_Status;
>>>>>> }
> 
>>>>>> Then you should know that DD simulated by HHH
>>>>>> according to the semantics of the C programming
>>>>>> language cannot possibly reach its own "return"
>>>>>> statement final halt state.
> 
>>>>> An argument like this is at such a low level of abstraction as to be near
>>>>> valuless.
> 
>>>> It is really weird that you are calling a 100% complete
>>>> concrete specification "a low level of abstraction".
>>>> That HHH(DD) correctly determines that DD simulated by
>>>> HHH cannot possibly halt is a proven fact.
> 
>>> A complete concrete specification would necessarily include a description
>>> of what you mean by "simulation".
> 
>> I specifically mean that this x86 machine code
> [ .... ]
>> Is emulated by an x86 emulator named HHH.
> 
> That's no adequate description.  To make it so, you'd have to say what
> you mean by an "x86 emulator".  The name you give it is irrelevant
> 

You are trying to trick me into infinite regress.
I don't tolerate this.

>>>   But my point was that rather than
>>> sticking to the abstract nature of the proof, you're chipping tiny pieces
>>> out of it and dealing with those.  The proof you claim to refute has no
>>> notion of simulation, for example; it doesn't need it.
> 
> 
>> *Not at all there are two pieces*
>> (1) HHH(DD) does correctly determine that its input
>>      specifies non halting behavior.
>> (2) The directly executed DD() does not contradict this.
> 
> The word "correctly" is fully redundant there.
> 

Some redundancy is required because most people here
only glance at my words before spouting off some ill
conceived fake rebuttal.

> The proof does not state whether the constructed function returns true or
> false, i.e. whether it specifies non halting behaviour.  It states
> nothing about "directly executed" anything.
> 

The you consistently refuse to pay close enough attention
is not my fault.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
   if Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
   if Ĥ applied to ⟨Ĥ⟩ does not halt

*if Ĥ applied to ⟨Ĥ⟩ halts*
specifies the direct execution of Ĥ applied to ⟨Ĥ⟩

I am going to repeat that a few more times hoping
that you may notice that I ever said it at least once.

*if Ĥ applied to ⟨Ĥ⟩ halts*
specifies the direct execution of Ĥ applied to ⟨Ĥ⟩

*if Ĥ applied to ⟨Ĥ⟩ halts*
specifies the direct execution of Ĥ applied to ⟨Ĥ⟩

*if Ĥ applied to ⟨Ĥ⟩ halts*
specifies the direct execution of Ĥ applied to ⟨Ĥ⟩

> You're not dealing with that proof, you're dealing with your own
> significantly different construction.  That is much less interesting.
> 

It only seems that way because you are not bothering
to pay close enough attention.

> [ .... ]
> 
>>>> Thus HHH(DD) does correctly determine that the halting
>>>> problem's counter-example input *DOES NOT HALT*
>>>> That you say this is "valueless" seems quite disingenuous.
> 
>>> It is a waste of time to discuss things at such an unnecessarily low
>>> level of abstraction.
> 
> 
>> It is just like you are saying that all huge things
>> are always very tiny. The high level of abstraction
>> of C is not any low level of abstraction.
> 
> It is when it is used as a proxy for steps of a proof.
> 

You don't seem to understand what the term levels
of abstraction means.

*Here are levels of abstraction from high to low in descending order*
(1) C
(2) assembly language
(3) machine language
(4) Turing machines

>>>>>    But analysing it a bit further, it is not clear exactly what
>>>>> you mean by "simulated by HHH".
> 
>>>> Do you have any idea what "simulation" means?
> 
>>> Yes.  I'm not sure you do,
> 
>> This should be something you learn in the first year of CS.
>> It is like an auto mechanic asking me: What is a spark plug?
>> The first thing that every programmer learns is that an
>> C language interpreter is not the same thing as a compiler.
> 
> I'm still not sure you understand what "simulation" means.
> 

I don't believe that you don't understand.

>>> though, which is why I was prompting you to be
>>> more concrete.  When Alan Turing published his seminal paper, he took a
>>> very great deal of space specifying exactly what he meant by a "machine".
> 
> [ .... ]
> 
>>> Whether endless recursion happens depends on whether HHH(DD) returns 0.
> 
>> Not at all.
> 
> It quite plainly does.
> 
>> *Don't erase this part make sure that you respond to it*
>> *Don't erase this part make sure that you respond to it*
>> *Don't erase this part make sure that you respond to it*
>> HHH simulates DD that calls HHH(DD)
>> that simulates DD that calls HHH(DD)
>> that simulates DD that calls HHH(DD)
>> that simulates DD that calls HHH(DD)
>> that simulates DD that calls HHH(DD)...
> 
> I've said before more than once, I'm not getting into fruitless
> discussions about things other people have dealt with adequately.
> 

In other words you and they both know that I
am correct thus have no basis for rebuttal.
========== REMAINDER OF ARTICLE TRUNCATED ==========