Path: ...!weretis.net!feeder9.news.weretis.net!feeder8.news.weretis.net!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: olcott <polcott333@gmail.com>
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 00:18:49 -0500
Organization: A noiseless patient Spider
Lines: 208
Message-ID: <v2harp$ehmg$5@dont-email.me>
References: <v0k4jc$laej$1@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>
 <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>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 May 2024 07:18:49 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="2f5f52f96f067406075e702eab09af4a";
	logging-data="476880"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+q9krKolxfS1M0G8zM1PB1"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:prYwVgCQvcP+LB+8Fmcs9PvY3I4=
In-Reply-To: <v2h1gp$1kiah$14@i2pn2.org>
Content-Language: en-US
Bytes: 10009

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.
>>>>
>>>
>>> Which thus doesn't correct simulate the call to H 
>>
>> *Counter-factual, try again*
>> We are not talking about any of your misconceptions the term:
>> "simulate" is expressly defined.
> 
> And how did your H "Correctly" simulate the call to H?
> 

That does not matter as long as it is not impossible.
========== REMAINDER OF ARTICLE TRUNCATED ==========