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: Halting Problem: What Constitutes Pathological Input
Date: Tue, 6 May 2025 18:41:28 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <49bd875b32c0963f4972d6154d2313ae1aaa3b52@i2pn2.org>
References: <GE4SP.47558$VBab.42930@fx08.ams4> <vvamqc$o6v5$4@dont-email.me>
 <vvan7q$o4v0$1@dont-email.me> <ts5SP.113145$_Npd.41800@fx01.ams4>
 <vvao8p$o4v0$2@dont-email.me> <vvav61$vtiu$5@dont-email.me>
 <vvavii$o4v0$5@dont-email.me> <vvb13p$vtiu$7@dont-email.me>
 <vvb2i9$o4v0$6@dont-email.me> <vvb3em$15u5b$3@dont-email.me>
 <vvckrg$2l1i4$1@dont-email.me> <vvd9h6$34l9k$5@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 6 May 2025 23:01:20 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="3438597"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <vvd9h6$34l9k$5@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0

On 5/6/25 11:23 AM, olcott wrote:
> On 5/6/2025 4:30 AM, Mikko wrote:
>> On 2025-05-05 19:27:18 +0000, olcott said:
>>
>>> On 5/5/2025 2:12 PM, dbush wrote:
>>>> On 5/5/2025 2:47 PM, olcott wrote:
>>>>> On 5/5/2025 1:21 PM, dbush wrote:
>>>>>> On 5/5/2025 2:14 PM, olcott wrote:
>>>>>>> On 5/5/2025 11:16 AM, dbush wrote:
>>>>>>>> On 5/5/2025 12:13 PM, Mr Flibble wrote:
>>>>>>>>> On Mon, 05 May 2025 11:58:50 -0400, dbush wrote:
>>>>>>>>>
>>>>>>>>>> On 5/5/2025 11:51 AM, olcott wrote:
>>>>>>>>>>> On 5/5/2025 10:17 AM, Mr Flibble wrote:
>>>>>>>>>>>> What constitutes halting problem pathological input:
>>>>>>>>>>>>
>>>>>>>>>>>> Input that would cause infinite recursion when using a 
>>>>>>>>>>>> decider of the
>>>>>>>>>>>> simulating kind.
>>>>>>>>>>>>
>>>>>>>>>>>> Such input forms a category error which results in the 
>>>>>>>>>>>> halting problem
>>>>>>>>>>>> being ill-formed as currently defined.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>> I prefer to look at it as a counter-example that refutes all 
>>>>>>>>>>> of the
>>>>>>>>>>> halting problem proofs.
>>>>>>>>>>
>>>>>>>>>> Which start with the assumption that the following mapping is 
>>>>>>>>>> computable
>>>>>>>>>> and that (in this case) HHH computes it:
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Given any algorithm (i.e. a fixed immutable sequence of 
>>>>>>>>>> instructions) X
>>>>>>>>>> described as <X> with input Y:
>>>>>>>>>>
>>>>>>>>>> A solution to the halting problem is an algorithm H that 
>>>>>>>>>> computes the
>>>>>>>>>> following mapping:
>>>>>>>>>>
>>>>>>>>>> (<X>,Y) maps to 1 if and only if X(Y) halts when executed 
>>>>>>>>>> directly
>>>>>>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
>>>>>>>>>> directly
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> int DD()
>>>>>>>>>>> {
>>>>>>>>>>>     int Halt_Status = HHH(DD);
>>>>>>>>>>>     if (Halt_Status)
>>>>>>>>>>>       HERE: goto HERE;
>>>>>>>>>>>     return Halt_Status;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>
>>>>>>>>>>> The x86utm operating system includes fully operational HHH 
>>>>>>>>>>> and DD.
>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>>>
>>>>>>>>>>> When HHH computes the mapping from *its input* to the 
>>>>>>>>>>> behavior of DD
>>>>>>>>>>> emulated by HHH this includes HHH emulating itself emulating 
>>>>>>>>>>> DD. This
>>>>>>>>>>> matches the infinite recursion behavior pattern.
>>>>>>>>>>>
>>>>>>>>>>> Thus the Halting Problem's "impossible" input is correctly 
>>>>>>>>>>> determined
>>>>>>>>>>> to be non-halting.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which is a contradiction.  Therefore the assumption that the 
>>>>>>>>>> above
>>>>>>>>>> mapping is computable is proven false, as Linz and others have 
>>>>>>>>>> proved
>>>>>>>>>> and as you have *explicitly* agreed is correct.
>>>>>>>>>
>>>>>>>>> The category (type) error manifests in all extant halting 
>>>>>>>>> problem proofs
>>>>>>>>> including Linz.  It is impossible to prove something which is 
>>>>>>>>> ill- formed
>>>>>>>>> in the first place.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> All algorithms either halt or do not halt when executed 
>>>>>>>> directly. Therefore the problem is not ill formed.
>>>>>>>>
>>>>>>>
>>>>>>> When BOTH Boolean RETURN VALUES are the wrong answer
>>>>>>> THEN THE PROBLEM IS ILL-FORMED. Self-contradiction must
>>>>>>> be screened out as semantically incorrect.
>>>>>>
>>>>>> In other words, you're claiming that there exists an algorithm, 
>>>>>> i.e. a fixed immutable sequence of instructions, that neither 
>>>>>> halts nor does not halt when executed directly.
>>>>>>
>>>>>
>>>>> That is not what I said.
>>>>
>>>> Then there's no category error, and the halting function is well 
>>>> defined.  It's just that no algorithm can compute it.
>>>
>>> It is insufficiently defined thus causing it
>>> to be incoherently defined.
>>
>> It is well defined. There are computations that halt and computations 
>> that
>> do not. Nothing else is in the scope of the halting problem.
>>
> 
> It is incorrectly defined when-so-ever it is not specified
> that a specific sequence of steps must be applied to the
> input to derive the output.

Functions don't define the steps that create the mapping.

It is algorithms that perform them

> 
> That DD() halts therefore I guess that DD correctly
> emulated by HHH must halt too IS NOT A SPECIFIC SEQUENCE OF STEPS.
> It is merely an incorrect guess.
> 

well, IF HHH did a correct emulation (which it doesn't) the it would see 
that, but since DD calls the actual HHH that does abort and return, that 
shows that the correct emulation of the input does halt.

All you are doing is proving you are a DAMN IDIOT LIAR as you know, or 
should know, that your HHH defined in Halt7.c doesn't correctly emulate 
DD, as it stops emulating when it see the call HHH instruction, IN 
VIOLATION of the definition of the CALL instruction,

Sorry, but you are just proving that by making clearly lying claims.