Path: ...!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory,sci.logic
Subject: Re: D simulated by H never halts no matter what H does
Date: Fri, 26 Apr 2024 20:26:11 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v0hgn3$2a19s$7@i2pn2.org>
References: <uvq0sg$21m7a$1@dont-email.me> <uvq359$1doq3$4@i2pn2.org>
 <uvrbvs$2acf7$1@dont-email.me> <uvs70t$1h01f$1@i2pn2.org>
 <uvsgcl$2i80k$1@dont-email.me> <uvsj4v$1h01e$1@i2pn2.org>
 <uvubo2$34nh3$1@dont-email.me> <uvvsap$3i5q8$1@dont-email.me>
 <v00mf6$3nu0r$1@dont-email.me> <v02gu5$6quf$1@dont-email.me>
 <v038om$bitp$2@dont-email.me> <v05b0k$sivu$1@dont-email.me>
 <v05r5e$vvml$2@dont-email.me> <v05vl4$1165d$1@dont-email.me>
 <v0679k$12sq2$1@dont-email.me> <v07r2j$1h57l$1@dont-email.me>
 <v08gn4$1lpta$2@dont-email.me> <v0ag7u$27jkb$1@dont-email.me>
 <v0b8np$2d4ja$1@dont-email.me> <v0c317$2538n$1@i2pn2.org>
 <v0c7fn$2k0tc$1@dont-email.me> <v0d3h1$2t938$1@dont-email.me>
 <v0doho$31mkn$2@dont-email.me> <v0forg$3j1dk$1@dont-email.me>
 <v0ghhm$3oudg$2@dont-email.me> <v0gk5q$2a19r$5@i2pn2.org>
 <v0gmrt$3qd6i$1@dont-email.me> <v0hfab$3vjo8$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 27 Apr 2024 00:26:11 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2426172"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <v0hfab$3vjo8$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 6445
Lines: 123

On 4/26/24 8:02 PM, olcott wrote:
> On 4/26/2024 12:05 PM, olcott wrote:
>> On 4/26/2024 11:19 AM, Richard Damon wrote:
>>> On 4/26/24 11:34 AM, olcott wrote:
>>>> On 4/26/2024 3:32 AM, Mikko wrote:
>>>>> On 2024-04-25 14:15:20 +0000, olcott said:
>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>> 02 {
>>>>>> 03   int Halt_Status = H(x, x);
>>>>>> 04   if (Halt_Status)
>>>>>> 05     HERE: goto HERE;
>>>>>> 06   return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 void main()
>>>>>> 10 {
>>>>>> 11   D(D);
>>>>>> 12 }
>>>>>>
>>>>>> That H(D,D) must report on the behavior of its caller is the
>>>>>> one that is incorrect.
>>>>>
>>>>> What H(D,D) must report is independet of what procedure (if any)
>>>>> calls it.
>>>>>
>>>>
>>>> Thus when H(D,D) correctly reports that its input D(D) cannot possibly
>>>> reach its own line 6 and halt no matter what H does then H can abort 
>>>> its
>>>> input and report that its input D(D) does not halt.
>>>
>>> But since the program D(D) DOES reach its own line 6 when run, 
>>> because H aborts its simulation and return 0 (since that is what you 
>>> say this H will do), your statement is PROVEN TO BE A LIE, and you 
>>> "logic" just a collection of contradictions.
>>>
>>
>> D simulated by H cannot possibly reach its own line 06 thus when we do
>> not use the strawman deception to refer to a different D then we know
>> that D simulated by H never halts.
>>
>>>>
>>>> The fact that the D(D) executed in main does halt is none of H's
>>>> business because H is not allowed to report on the behavior of its
>>>> caller.
>>>>
>>>
>>> In other words, H doesn't need to report on the Behavior of the 
>>> Program described by its input because it isn't actually a Halt 
>>> Decider, because you are just a LIAR.
>>>
>>>
>>
>> Anyone knowing the theory of computation knows that H is not allowed to
>> report on the behavior of its caller.
>>
>> In computability theory and computational complexity theory, an
>> undecidable problem is a decision problem for which it is proved to be
>> impossible to construct an algorithm that always leads to a correct yes-
>> or-no answer. https://en.wikipedia.org/wiki/Undecidable_problem
>>
>> The behavior of the simulated D(D) before H aborts its simulation is
>> different than the behavior of the executed D(D) after H has aborted
>> its simulation.
>>
>> Every time that a simulated input would never stop running unless
>> aborted the simulating termination analyzer must abort this simulation
>> to prevent its own infinite execution.
>>
>> H(D,D) is a case of this H1(D,D) is not a case of this even though
>> the only difference between H and H1 is that D calls H and D does
>> not call H1.
>>
>> D simulated by H would never stop running unless aborted and cannot
>> possibly reach its own line 06 and halt no matter what H does.
>>
>> Thus whenever we do not use the strawman deception to refer to a
>> different D we know that D simulated by H specifies a non-halting
>> sequence of configurations to H.
>>
> 
> *This might be a more succinct way of summing that up*
> When you understand that D simulated by H cannot possibly reach past its 
> own line 03 (thus cannot possibly halt) no matter what H does and

But since H does whatever H does, if H aborts and returns 0, the the 
direct execution of D, which is what actually matters, DOES get to that 
point.


> 
> you understand that it is incorrect for H to report on the behavior of 
> its caller: void main() { D(D); } then this necessitates

But it MUST report on the program described to it, which is a call to 
D(D), and it doesn't matter if that is what calls H.

So, your claim is just a STUPID LIE.

Yes, you can't ask "What is the behavior of the program that called you?"

But you CAN ask what is the behavior of M(d) even if M(d) happens to 
call you.

You are just proving you total lack of understand of the nature of the 
problem.

> 
> H can abort its simulation of D and correctly report that D specifies a 
> non-halting sequence of configurations.
> 

Nope, it CAN'T correctly say that a program that will halt when run is 
none halting.

Your claiming it can just proves that you are just a STUPID LIAR.

You seem to believe it is correct to give wrong answer, but I suppose 
that should be expected from someone who doesn't understand the basic 
nature of truth and who has been shown to be a pathological liar.

You have probabably doomed to oblivian any piece of your ideas that 
might have some usefulness by the taint of your illogical stupidity that 
you have been spewing.