Path: ...!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
Subject: Re: Halting Problem: What Constitutes Pathological Input
Date: Wed, 7 May 2025 22:21:25 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <473b8403ad7286d2ebc8c002d1bd0068412bdc60@i2pn2.org>
References: <GE4SP.47558$VBab.42930@fx08.ams4> <vvatf3$o4v0$3@dont-email.me>
 <vvaut0$vtiu$4@dont-email.me> <vvav6o$o4v0$4@dont-email.me>
 <vvb329$15u5b$1@dont-email.me> <vvb37g$1451r$1@dont-email.me>
 <vvb43f$15u5b$4@dont-email.me> <vvb4ok$o4v0$9@dont-email.me>
 <vvb52g$15u5b$6@dont-email.me> <vvb5ca$o4v0$10@dont-email.me>
 <vvb5vp$15u5b$7@dont-email.me> <vvb675$o4v0$11@dont-email.me>
 <vvb9d7$1av94$3@dont-email.me> <vvbani$1b6l1$1@dont-email.me>
 <vvbb6s$1av94$4@dont-email.me> <vvbcb3$1b6l1$2@dont-email.me>
 <vvbe0j$1av94$8@dont-email.me> <vvbecc$1b6l1$6@dont-email.me>
 <vvbhk0$1ijna$1@dont-email.me> <vvbjjg$1kegb$1@dont-email.me>
 <vvbk93$1l4cf$1@dont-email.me> <vvbkft$1kegb$4@dont-email.me>
 <vvbl71$1ljaj$1@dont-email.me> <vvbma3$1kegb$5@dont-email.me>
 <vvbmp0$1ljaj$2@dont-email.me> <vvbqd5$1tr5o$1@dont-email.me>
 <vvbrha$1us1f$1@dont-email.me>
 <b5dffdb99fdbfe0cd74914de4d51abe0aa439e7d@i2pn2.org>
 <vvdj0r$3cbpq$9@dont-email.me> <vvf73c$tv4n$1@dont-email.me>
 <vvfvbv$130t3$8@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Thu, 8 May 2025 02:46:30 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="3599436"; 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: <vvfvbv$130t3$8@dont-email.me>
Bytes: 4527
Lines: 73

On 5/7/25 11:48 AM, olcott wrote:
> On 5/7/2025 3:54 AM, Mikko wrote:
>> On 2025-05-06 18:05:15 +0000, olcott said:
>>
>>> That everyone here thinks that HHH can simply ignore
>>> the rules of the x86 language and jump over the "call"
>>> instruction to the "ret" instruction seems quite stupid
>>> to me.
>>
>> The halting problem does not prohibit such skip so in that sense
>> it is OK.
>>
>> However, in order to correctly determine whether DD halts
>> it may need to know whether the called HHH returns and what it
>> returns if it does.
>>
> 
> The call from DD emulated by HHH cannot possibly return.

Only because HHH can't be a correct emulator.

> 
> The recursive emulation just keep getting deeper until
> HHH correctly recognizes that DD would never stop running
> in the hypothetical case that this HHH never aborted.

And because it recognises that, ALL copies of DD become halting, as the 
correct emulation of them, which HHH has abandoned, reaches the final state.

You have decided that you hypothetical square circle has 4 corners, but 
of course, it turns out that it isn't a circle anymore, just like you 
HHH isn't a correct emulator anymore.

> 
>> When discussing the situation we need not consider what happens
>> during the execution of HHH. We do know that HHH returns if it
>> really is a halt decider or any other decider. 
> 
> The fully operational code has shown 100% of all of
> the details of this for three years.

And it proves that HHH is wrong.

> 
> The call from DD correctly emulated by HHH to
> HHH(DD) cannot possibly return. This makes the
> self-contradictory part of DD unreachable.

JNo, it proves you beleive in square circles, as HHH doesn't correctly 
emulate its input, but you claim it does.

> 
>> We also know that
>> if it returns it either returns zero or someting else. The code
>> of DD shows that it halts if HHH(DD) returns zero and does not
>> halt fi HHH(DD) returns non-zero or does not return at all.
>>
> 
> DD cannot possibly
> *do the opposite of whatever value that HHH returns*
> because this code is unreachable from DD correctly
> emulated by HHH.
> 

But HHH doesn't correctly emulate its input, so that case doesn't happen.

But DD does see the results of HHH when the input is actually correctly 
emulated (like with a UTM), and since THAT matches the behavior 
requested by the mapping of the problem, provides the correct answer, 
which isn't what HHH returns, so it is wrong.

All you are doing is proving you beleive in lies and equivacated 
definitions.