Path: ...!news.misty.com!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Every D(D) simulated by H presents non-halting behavior to H ###
Date: Sun, 19 May 2024 13:17:50 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v2dc7u$1g2n9$9@i2pn2.org>
References: <v18e32$1vbql$1@dont-email.me> <v1gid8$4ilc$1@dont-email.me>
 <v1h9eu$9faf$1@dont-email.me> <v1iqli$nsva$1@dont-email.me>
 <v1ln3c$vfh$1@news.muc.de> <v1s6e6$397iq$2@dont-email.me>
 <v1slmi$3cjtp$1@dont-email.me> <v1t8tt$3gu9t$3@dont-email.me>
 <v1vc8j$3jmr$1@dont-email.me> <v1vsru$7eqc$1@dont-email.me>
 <v21r4i$otc2$2@dont-email.me> <v22k4b$umr4$1@dont-email.me>
 <v24oah$1h4u3$1@dont-email.me> <v256fc$1kais$1@dont-email.me>
 <v25bf0$ecc$1@news.muc.de> <v25crp$1lmq1$1@dont-email.me>
 <v28d3q$nic$1@news.muc.de> <v28njc$2dp3s$1@dont-email.me>
 <v28odm$2dlle$1@dont-email.me> <v28sg6$2ehk3$1@dont-email.me>
 <v2bptb$36ei8$1@dont-email.me> <v2brju$36n5f$3@dont-email.me>
 <v2bsk8$36ug8$1@dont-email.me> <v2bsut$36vvc$2@dont-email.me>
 <v2cqgt$3cek2$1@dont-email.me> <v2ctq0$3d05c$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 19 May 2024 17:17:50 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1575657"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <v2ctq0$3d05c$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 4822
Lines: 90

On 5/19/24 9:11 AM, olcott wrote:
> On 5/19/2024 7:15 AM, immibis wrote:
>> On 19/05/24 05:50, olcott wrote:
>>> On 5/18/2024 10:45 PM, immibis wrote:
>>>> On 19/05/24 05:27, olcott wrote:
>>>>> Yes and several people also continue to point out that D
>>>>> correctly simulated by H can reach its own line 06 and halt
>>>>> even when an execution trace of H simulating itself simulating
>>>>> D proves otherwise.
>>>>
>>>> You don't understand that a correct simulation does the same thing 
>>>> as the real program. A correct simulation of D doesn't reach line 06 
>>>> if D outside of a simulation doesn't reach line 06.
>>>>
>>>> If D outside of a simulation reaches line 06 but D inside of a 
>>>> simulation doesn't reach line 06 then the simulation is wrong.
>>>
>>> *We have not gotten to that point in the dialog yet*
>>>
>>
>> we got to it many times before
>>
> 
> People glance at a few things that I say and then leap to the
> conclusion that I must be wrong without systematically evaluating
> every step of my proof.
> 
> People call me a liar without ever actually showing that I am incorrect.

No, YOU call people liars, saying they haven't said something, when they 
actually have, so YOU are the one proved to be the LIAR.



> 
>>> Every element of an infinite set of H/D pairs matching a template
>>> where H correctly simulates 1 to ∞ steps of D thus including
>>> 0 to ∞ recursive simulations of H simulating itself simulating D.
>>> *No D correctly simulating by H ever reaches its own line 06 and halts*
>>
>> this doesn't make sense
> 
> Here is the context of that.
> 
> 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 }
> 
> 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.
> 
> The key thing to note is that no D simulated correctly by any H of every
> H/D pair specified by the above template ever reaches its own line 06 
> and halts.
> 
> The above is self-evidently true to anyone having sufficient
> knowledge of the semantics of the C programming language.
> 
> 

But proven wrong, so your concept of "Self-Evident" is broken, and 
NOTHING you call "Self-evident" should be taken at face value, and to a 
gambling man, perhaps a good thing to bet against.