Path: ...!2.eu.feeder.erje.net!3.eu.feeder.erje.net!feeder.erje.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: Can D simulated by H terminate normally? --- Message_ID Provided
Date: Mon, 20 May 2024 13:17:41 -0500
Organization: A noiseless patient Spider
Lines: 215
Message-ID: <v2g446$49kb$1@dont-email.me>
References: <v0k4jc$laej$1@dont-email.me> <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> <v2b179$2u8oi$2@dont-email.me>
 <v2b1g3$1ct7p$17@i2pn2.org> <v2bb0g$308qd$1@dont-email.me>
 <v2bc8u$1ecj9$4@i2pn2.org> <v2bdaj$30o5r$1@dont-email.me>
 <v2be6g$1ecja$2@i2pn2.org> <v2btfr$36vvc$3@dont-email.me>
 <v2cqii$3cek2$2@dont-email.me> <v2cthk$3d018$1@dont-email.me>
 <v2ek1t$3qnl3$1@dont-email.me> <v2emdh$3r3vn$1@dont-email.me>
 <v2fbtr$1g2n8$11@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 20 May 2024 20:17:43 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="629f9cefad5d4023792ce8f8ed8d9594";
	logging-data="140939"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+byLU19P77rNGwcVpGDvZQ"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:sNTnyKO29u5rLHhZQr2cnLdGGkw=
In-Reply-To: <v2fbtr$1g2n8$11@i2pn2.org>
Content-Language: en-US
Bytes: 10004

On 5/20/2024 6:24 AM, Richard Damon wrote:
> On 5/20/24 1:17 AM, olcott wrote:
>> On 5/19/2024 11:37 PM, immibis wrote:
>>> On 19/05/24 15:06, olcott wrote:
>>>> On 5/19/2024 7:16 AM, immibis wrote:
>>>>> On 19/05/24 05:59, olcott wrote:
>>>>>> On 5/18/2024 6:38 PM, Richard Damon wrote:
>>>>>>> On 5/18/24 7:24 PM, olcott wrote:
>>>>>>>> On 5/18/2024 6:06 PM, Richard Damon wrote:
>>>>>>>>> On 5/18/24 6:44 PM, olcott wrote:
>>>>>>>>>> On 5/18/2024 3:02 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/18/24 3:57 PM, olcott wrote:
>>>>>>>>>>>> On 5/1/2024 7:10 PM, Richard Damon wrote:
>>>>>>>>>>>>> The second method uses the fact that you have not 
>>>>>>>>>>>>> restricted what H is allowed to do, and thus H can remember 
>>>>>>>>>>>>> that it is simulating, and if a call to H shows that it is 
>>>>>>>>>>>>> currently doing a simulation, just immediately return 0. 
>>>>>>>>>>>>
>>>>>>>>>>>> Nice try but this has no effect on any D correctly simulated 
>>>>>>>>>>>> by H.
>>>>>>>>>>>> When the directly executed H aborts its simulation it only 
>>>>>>>>>>>> returns
>>>>>>>>>>>> to whatever directly executed it.
>>>>>>>>>>>
>>>>>>>>>>> Why? My H does correctly simulate the D it was given.
>>>>>>>>>>>
>>>>>>>>>>> You don't seem to understand how the C code actually works.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If the directly executed outermost H does not abort then 
>>>>>>>>>>>> none of
>>>>>>>>>>>> the inner simulated ones abort because they are the exact 
>>>>>>>>>>>> same code.
>>>>>>>>>>>> When the directly executed outermost H does abort it can 
>>>>>>>>>>>> only return
>>>>>>>>>>>> to its own caller.
>>>>>>>>>>>
>>>>>>>>>>> WHAT inner simulatioin?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> My H begins as:
>>>>>>>>>>>
>>>>>>>>>>> int H(ptr x, ptr y) {
>>>>>>>>>>>    static int flag = 0;
>>>>>>>>>>>    if(flag) return 0;
>>>>>>>>>>>    flag = 1;
>>>>>>>>>>>
>>>>>>>>>>> followed by essentially your code for H, except that you need 
>>>>>>>>>>> to disable the hack that doesn't simulate the call to H, but 
>>>>>>>>>>> just let it continue into H where it will immediately return 
>>>>>>>>>>> to D and D will then return.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Thus, your claim is shown to be wrong.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We are talking about every element of an infinite set where
>>>>>>>>>> H correctly simulates 1 to ∞ steps of D thus including 0 to ∞
>>>>>>>>>> recursive simulations of H simulating itself simulating D.
>>>>>>>>>>
>>>>>>>>>> *At whatever point the directly executed H(D,D) stops simulating*
>>>>>>>>>> *its input it cannot possibly return to any simulated input*
>>>>>>>>>
>>>>>>>>> And my H never stops simulating, so that doesn't apply. It will 
>>>>>>>>> reach the final state.
>>>>>>>>
>>>>>>>> *Show the error in my execution trace that I empirically*
>>>>>>>> *proved has no error by H correctly simulating D to the*
>>>>>>>> *point where H correctly simulates itself simulating D*
>>>>>>>> (Fully operational empirically code proved this)
>>>>>>>
>>>>>>> See below:
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> typedef int (*ptr)();  // ptr is pointer to int function
>>>>>>>> 00 int H(ptr x, ptr y);
>>>>>>>> 01 int D(ptr x)
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 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 }
>>>>>>>
>>>>>>> For Reference
>>>>>>>
>>>>>>> 14 int H(ptr x, ptr y)
>>>>>>> 15 {
>>>>>>> 16   static int flag = 0
>>>>>>> 17   if (flag)
>>>>>>> 18      return 0
>>>>>>> 19   ... continuation of H that simulates its input
>>>>>>>
>>>>>>>>
>>>>>>>> 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)
>>>>>>>
>>>>>>> Line 03: Calls H (line 14)
>>>>>>> Line 16: Static already inited, so not changed.
>>>>>>> Line 17: Flag is 1, so
>>>>>>> Line 18: Return 0
>>>>>>> Line 03: Set Halt_Status to 0
>>>>>>> Line 04: if (Halt_Status)      halts status is 0, so skip
>>>>>>> Line 06: return Halt_Status
>>>>>>>
>>>>>>> Simulation completed, program halted.
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> Simulation invariant:
>>>>>>>> D correctly simulated by H cannot possibly reach past its own 
>>>>>>>> line 03.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Nope. Not for this H
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> (a) That idea might work yet you did not say it correctly.
>>>>>> For example line 11 is the first one invoked.
>>>>>> (b) Computable functions cannot alter their behavior this way.
>>>>>>
>>>>>> (1) the function return values are identical for identical 
>>>>>> arguments (no
>>>>>> variation with local static variables, non-local variables, mutable
>>>>>> reference arguments or input streams, i.e., referential 
>>>>>> transparency), and
>>>>>
>>>>> Your function H works like Richard's function H. You just called 
>>>>> the variable "execution trace" instead of "flag".
>>>>
>>>> pages 4-5 (of a paper that I published 2021-09-26 09:39 AM)
>>>> Show H simulating P and H simulating itself simulating P.
>>>>
>>>> The 395 pages of the execution trace of the simulated H are
>>>> screened out. No one here could ever understand the half page
>>>> trace so embedding that in 395 more pages would not help.
>>>
>>> The fact that you took 395 pages to get to "if(flag) return 0;" does 
>>> not mean that you didn't use "if(flag) return 0;"
>>>
========== REMAINDER OF ARTICLE TRUNCATED ==========