Path: ...!weretis.net!feeder9.news.weretis.net!news.nk.ca!rocksolid2!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 possibly reach its own
 line 06 and halt
Date: Tue, 21 May 2024 23:09:50 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v2jnlu$1nrfv$1@i2pn2.org>
References: <v0k4jc$laej$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>
 <v2edto$3pl2i$2@dont-email.me> <v2ef1c$1g2n9$14@i2pn2.org>
 <v2efle$3q0ko$1@dont-email.me> <v2fbtp$1g2n8$10@i2pn2.org>
 <v2g390$3ugq$6@dont-email.me> <v2grhq$1kiah$6@i2pn2.org>
 <v2h0nm$d87m$1@dont-email.me> <v2h1gp$1kiah$14@i2pn2.org>
 <v2harp$ehmg$5@dont-email.me> <v2i2it$1kiag$2@i2pn2.org>
 <v2ian9$ko3b$1@dont-email.me> <v2jiop$1no6v$1@i2pn2.org>
 <v2jju1$vqej$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 22 May 2024 03:09:50 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1830399"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <v2jju1$vqej$1@dont-email.me>
Bytes: 20688
Lines: 492

On 5/21/24 10:05 PM, olcott wrote:
> On 5/21/2024 8:46 PM, Richard Damon wrote:
>> On 5/21/24 10:22 AM, olcott wrote:
>>> On 5/21/2024 7:03 AM, Richard Damon wrote:
>>>> On 5/21/24 1:18 AM, olcott wrote:
>>>>> On 5/20/2024 9:39 PM, Richard Damon wrote:
>>>>>> On 5/20/24 10:25 PM, olcott wrote:
>>>>>>> On 5/20/2024 7:57 PM, Richard Damon wrote:
>>>>>>>> On 5/20/24 2:03 PM, olcott wrote:
>>>>>>>>> On 5/20/2024 6:24 AM, Richard Damon wrote:
>>>>>>>>>> On 5/19/24 11:22 PM, olcott wrote:
>>>>>>>>>>> On 5/19/2024 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/19/24 10:52 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> OK, good.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, so it doesn't matter what any other D does, it 
>>>>>>>>>>>> matters what THIS D does, and this D calls aths H.
>>>>>>>>>>>>
>>>>>>>>>>>> Remember, you reinstated the Computation model by enforcing 
>>>>>>>>>>>> Pure Functions.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> <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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is off-topic for this post.
>>>>>>>>>>>>> All that we need know is that no D simulated by any H
>>>>>>>>>>>>> ever reaches its own line 06 and halts.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope. Make a claim, you need to prove it.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *In other different post not this one*
>>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> But you can't PRECISELY define the category, or what you want 
>>>>>>>>>> to reason about, so your logic is worthless as it is baseless.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *POINT TO ANY ACTUAL MISTAKE OR AMBIGUITY WITH THIS VERSION*
>>>>>>>>>
>>>>>>>>> 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.
========== REMAINDER OF ARTICLE TRUNCATED ==========