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: Every D correctly simulated by H cannot possible reach its own
 line 06 and halt
Date: Mon, 20 May 2024 20:57:33 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v2grht$1kiah$7@i2pn2.org>
References: <v0k4jc$laej$1@dont-email.me> <v0loq2$2g493$1@i2pn2.org>
 <v0lq7d$14579$2@dont-email.me> <v0ls98$2g492$7@i2pn2.org>
 <v0m29q$166o1$1@dont-email.me> <v0m37e$2gl1e$1@i2pn2.org>
 <v0m3v5$16k3h$1@dont-email.me> <v0m55t$2gl1f$3@i2pn2.org>
 <v0m5sn$172p4$1@dont-email.me> <v0m7em$2gl1f$5@i2pn2.org>
 <v0m7tq$17dpv$1@dont-email.me> <v0m8g9$2gl1e$6@i2pn2.org>
 <v0m978$17k7o$3@dont-email.me> <v0mko6$2hf3s$2@i2pn2.org>
 <v0n59h$1h98e$1@dont-email.me> <v0o037$2j1tu$3@i2pn2.org>
 <v0oc65$1q3aq$3@dont-email.me> <v0p9ts$2ki5r$6@i2pn2.org>
 <v0q1rk$2a3u1$1@dont-email.me> <v0qkti$2m1nf$1@i2pn2.org>
 <v0r4a3$2hb7o$6@dont-email.me> <v0rsbr$2m1nf$6@i2pn2.org>
 <v0segm$2v4oq$1@dont-email.me> <v0t8o9$2p3ri$2@i2pn2.org>
 <v0tpjf$3881i$5@dont-email.me> <v0ulma$2qov4$1@i2pn2.org>
 <v2e45j$3kf2k$1@dont-email.me> <v2e7up$1g2n9$13@i2pn2.org>
 <v2eet5$3pl2i$3@dont-email.me> <v2efoi$1g2n9$15@i2pn2.org>
 <v2eg8o$3q3cl$1@dont-email.me> <v2fbtn$1g2n8$9@i2pn2.org>
 <v2g35j$3ugq$5@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 May 2024 00:57:33 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1722705"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <v2g35j$3ugq$5@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 7829
Lines: 154

On 5/20/24 2:01 PM, olcott wrote:
> On 5/20/2024 6:24 AM, Richard Damon wrote:
>> On 5/19/24 11:32 PM, olcott wrote:
>>> On 5/19/2024 10:24 PM, Richard Damon wrote:
>>>> On 5/19/24 11:09 PM, olcott wrote:
>>>>> On 5/19/2024 8:10 PM, Richard Damon wrote:
>>>>>> On 5/19/24 8:06 PM, olcott wrote:
>>>>>>> On 5/1/2024 7:10 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> typedef int (*ptr)();  // ptr is pointer to int function
>>>>>>> 00 int H(ptr p, ptr i);
>>>>>>> 01 int D(ptr p)
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(p, p);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 int main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12   return 0;
>>>>>>> 13 }
>>>>>>>
>>>>>>> In the above case a simulator is an x86 emulator that correctly 
>>>>>>> emulates at least one of the x86 instructions of D in the order 
>>>>>>> specified by the x86 instructions of D.
>>>>>>>
>>>>>>> This may include correctly emulating the x86 instructions of H in 
>>>>>>> the order specified by the x86 instructions of H thus calling 
>>>>>>> H(D,D) in recursive simulation.
>>>>>>>
>>>>>>> For every H/D pair of the above template D correctly simulated by
>>>>>>> *pure function* H cannot possibly reach its own final state at
>>>>>>> line 06 and halt.
>>>>>>>
>>>>>>
>>>>>> Ok, so adding that H is a pure function, that means that since 
>>>>>> your outer H(D,D) is going to return 0, all logic must be 
>>>>>> compatible with the fact that EVERY call to H(D,D) will also 
>>>>>> eventually return 0.
>>>>>>
>>>>>>
>>>>>> Remember also, THIS D is defined to call THIS H, that does exactly 
>>>>>> the same as the H that is deciding it.
>>>>>>
>>>>>>>
>>>>>>> <snip so that Message ID links to whole message>
>>>>>>> We can use my unique time/date stamp as an alternative.
>>>>>>>
>>>>>>>> Remember, YOU are the one saying you are needing to change the 
>>>>>>>> definition from the classical theory, where we have things well 
>>>>>>>> defined.
>>>>>>>>
>>>>>>>> YOU have decider that H is just whatever C code you want to 
>>>>>>>> write for it, and D is the input proved. (which doesn't actually 
>>>>>>>> match the Linz or Sipser proof, but fairly close).
>>>>>>>>
>>>>>>>> With THAT set of definitions we have a lot of options that break 
>>>>>>>> your incorrectly assumed results.
>>>>>>>>
>>>>>>>> The first method has been discussed here by Flibble. While the 
>>>>>>>> final answer he got to doesn't fit the requirements, the first 
>>>>>>>> part of the method DOES show that it is possible for an H to 
>>>>>>>> simulate to past line 3.
>>>>>>>>
>>>>>>>> THe basic idea is that if H(M,d) finds that its simulation of 
>>>>>>>> M(d) get to a call to H(M,d) then rather that your idea of just 
>>>>>>>> saying it will get stuck and declair the input invalid, since 
>>>>>>>> there ARE a number of possible inputs that there is a "correct" 
>>>>>>>> answer that H can give to 
>>>>>>>
>>>>>>> That D is calling H does not prove recursive simulation.
>>>>>>> That D is calling H with its same parameters does seem
>>>>>>> to prove non-halting recursive simulation.
>>>>>>
>>>>>> Nope. Try to actuall PROVE it.
>>>>>
>>>>> I am using categorically exhaustive reasoning that can work
>>>>> through every possibility that can possibly exist in a feasible
>>>>> amount of time as long as the category is very very narrow.
>>>>
>>>> What "Category", we have a specified H and an SPECIFIED D.
>>>>
>>>> The question is not, can H simulate D to the end, the question is 
>>>> does D halt.
>>>>
>>>
>>> *The subject is in the subject line you diverged, please try again*
>>> *The subject is in the subject line you diverged, please try again*
>>> *The subject is in the subject line you diverged, please try again*
>>>
>>
>> And since YOU brought up the diversion, I just asked you to define it.
>>
> 
> typedef int (*ptr)();  // ptr is pointer to int function
> 00 int H(ptr p, ptr i);
> 01 int D(ptr p)
> 02 {
> 03   int Halt_Status = H(p, p);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 int main()
> 10 {
> 11   H(D,D);
> 12   return 0;
> 13 }
> 
> In the above case a simulator is an x86 emulator that correctly emulates 
> at least one of the x86 instructions of D in the order specified by the 
> x86 instructions of D.
> 
> This may include correctly emulating the x86 instructions of H in the 
> order specified by the x86 instructions of H thus calling H(D,D) in 
> recursive simulation.
> 
> Execution Trace
> Line 11: main() invokes H(D,D);
> 
> keeps repeating (unless aborted)
> Line 01:
> Line 02:
> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
> 
> Simulation invariant:
> D correctly simulated by H cannot possibly reach past its own line 03.
> 
> For every H/D pair of the above template D correctly simulated by pure 
> function (thus computable function) H cannot possibly reach its own 
> final state at line 06 and halt.
> 

But a computable function is not a pure function, and the comparion is 
just a type error.

A "Computable Function" as a mathematic concept which represent a 
mathematical mapping of input to output.

Your program is the "algorith" that computes that mapping. It is NOT the 
mapping itself.

And, the "Flibble" structure can correctly simulate the code in D (given 
the assumption that you can detect D calling H(D,D) like you H does) to 
the point of determing that there is no answer that H can give to be 
correct. It thus can handle the non-contradictory version of D, that 
your H will just give up on.

Your H deteremines that YOUR H doesn't halt, so proves that it can't be 
a halt decider. (Either H doesn't actually halt, or it lies and gives 
the wrong answer).