Path: news.eternal-september.org!eternal-september.org!feeder3.eternal-september.org!news.quux.org!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Everyone on this forum besides Keith has been a damned liar about
 this point
Date: Tue, 10 Jun 2025 07:24:20 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <62f0d331bd0d0519682207acf598694d84cac114@i2pn2.org>
References: <1025i6j$afk6$1@dont-email.me> <1025j6l$4nm5$1@dont-email.me>
 <1025jn5$aqju$1@dont-email.me> <1025kkk$4nm5$2@dont-email.me>
 <1025l2e$aqju$3@dont-email.me> <1025l7l$4nm5$3@dont-email.me>
 <1025n51$b964$2@dont-email.me> <1026d6e$g0hl$2@dont-email.me>
 <1026rvc$j3rp$3@dont-email.me>
 <bcf9f5c929d87513847a8bca27b31e184d447e84@i2pn2.org>
 <1027vah$r7bj$5@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 10 Jun 2025 11:38:39 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="4096574"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
In-Reply-To: <1027vah$r7bj$5@dont-email.me>

On 6/9/25 8:47 PM, olcott wrote:
> On 6/9/2025 7:26 PM, Richard Damon wrote:
>> On 6/9/25 10:43 AM, olcott wrote:
>>> On 6/9/2025 5:31 AM, Fred. Zwarts wrote:
>>>> Op 09.jun.2025 om 06:15 schreef olcott:
>>>>> On 6/8/2025 10:42 PM, dbush wrote:
>>>>>> On 6/8/2025 11:39 PM, olcott wrote:
>>>>>>> On 6/8/2025 10:32 PM, dbush wrote:
>>>>>>>> On 6/8/2025 11:16 PM, olcott wrote:
>>>>>>>>> On 6/8/2025 10:08 PM, dbush wrote:
>>>>>>>>>> On 6/8/2025 10:50 PM, olcott wrote:
>>>>>>>>>>> void DDD()
>>>>>>>>>>> {
>>>>>>>>>>>    HHH(DDD);
>>>>>>>>>>>    return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> The *input* to simulating termination analyzer HHH(DDD)
>>>>>>>>>>
>>>>>>>>>> No it's not, as halt deciders / termination analyzers work 
>>>>>>>>>> with algorithms,
>>>>>>>>>
>>>>>>>>> That is stupidly counter-factual.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That you think that shows that 
>>>>>>>
>>>>>>> My understanding is deeper than yours.
>>>>>>> No decider ever takes any algorithm as its input.
>>>>>>
>>>>>> But they take a description/specification of an algorithm,
>>>>>
>>>>> There you go.
>>>>>
>>>>>> which is what is meant in this context. 
>>>>>
>>>>> It turns out that this detail makes a big difference.
>>>>>
>>>>>> And because your HHH does not work with the description/ 
>>>>>> specification of an algorithm, by your own admission, you're not 
>>>>>> working on the halting problem.
>>>>>>
>>>>>
>>>>> HHH(DDD) takes a finite string of x86 instructions
>>>>> that specify that HHH simulates itself simulating DDD.
>>>>
>>>> And HHH fails to see the specification of the x86 instructions. It 
>>>> aborts before it can see how the program ends.
>>>>
>>>
>>> This is merely a lack of sufficient technical competence
>>> on your part. It is a verified fact that unless the outer
>>> HHH aborts its simulation of DDD that DDD simulated by HHH
>>> the directly executed DDD() and the directly executed HHH()
>>> would never stop running. That you cannot directly see this
>>> is merely your own lack of sufficient technical competence.
>>
>> And it is a verified fact that you just ignore that if HHH does in 
>> fact abort its simulation of DDD and return 0, then the behavior of 
>> the input, PER THE ACTUAL DEFINITIONS, is to Halt, and thus HHH is 
>> just incorrect.
>>
> 
> void DDD()
> {
>    HHH(DDD);
>    return;
> }
> 
> How the f-ck does DDD correctly simulated by HHH
> reach its own "return" statement final halt state?

Who said correctly simulated by HHH?

You need to make a decision on which part of your arguement is a lie?

Is HHH a program? if not, your whole argument is a category error. (you 
have actually admitted this error)

If it is a program, then it has a fixed behavior. Is that behavior to 
correctly simulate its input and not abort, or is it at some point to 
abort its simulation.

If it does correctly simulate its input, then as you have shown, it just 
doesn't ever return an answer, and thus isn't a correct decider.

If HHH does abort and return, then the correct simulation of the input 
(which isn't done by HHH) will reach the final state.

Your thinking that both of these behaviors are possible in a single 
program just shows you don't know what you are talking about

> 
> _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
> 

Since the above is NOT a complete program, it just can not be correctly 
simulated, as we can't complete the simulation of the call 000015d2 
instruction.

You have made it clear that this is the WHOLE of the input, and thus 
anything that uses any other information is no longer "simulating the 
input", and your claims are thus based on lying that that is what they 
are doung,

> How the f-ck does DDD correctly emulated by HHH
> reach its own "ret" instruction final halt state?
> 
> That you have dodged this question hundreds of times
> proves that you are a liar.
> 

That you keep on putting forward this strawman, just shows your stupidity.

You have stated that the use of strawman arguments are an error, but you 
continue to do so, because that is just the sort of person you are.

The question is NOT can HHH correctly simulate the input to the final 
state, but does the correct simulation of the input reach a final state.

If HHH does actually fully attempt to do so, it fails to be a decider

If HHH gives up and aborts so it can answer, then your criteria fails to 
have meaning,

So, your strawman argument is just shown to be built on error.