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: Proof that DD correctly simulated by HH has different behavior
 than DD(DD) STEP(1)
Date: Sat, 8 Jun 2024 16:32:36 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v42f55$3cg3t$28@i2pn2.org>
References: <v428vv$2no74$2@dont-email.me> <v42cjt$2p81p$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 8 Jun 2024 20:32:37 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="3555453"; 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: <v42cjt$2p81p$1@dont-email.me>
Bytes: 6385
Lines: 111

On 6/8/24 3:49 PM, olcott wrote:
> *This has been corrected so that it can be verified that*
> *the execution trace matches the x86 source-code of DD*
> (two versions of my text files were out-of-sync)
> 
> Before we can get to the behavior of the directly executed
> DD(DD) we must first see that the Sipser approved criteria
> have been met:
> 
> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
> If simulating halt decider H correctly simulates its input D
> until H correctly determines that its simulated D would never
> stop running unless aborted then
> 
> H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>

Which, since his definition of "Correct Simulation" is not yours, you 
can not use.

For you to use it, you need to first show that your H actually does a 
correct simulation of the input, which is a simualation that actually 
recreates the behavior of the input, which requires a simulation that 
never aborts.

Since your H doesn't do this, your logic fails.

Sipser would also allow for us to hypothocate that THIS H changes into 
such a simulator, but in doing so, the input does not change (since it 
can't) and thus for your system, that means the DD still says paired 
with the original HH that you are going to claim to be correct.

Since that simulation WILL HALT if H ever decides to abort and return 0, 
as long as that option remains, H can never correctly determine that its 
simulation would not halt if not aborted.

So, you FAIL to acheive the requirements, and can not use the clause 
that you did use, so you have lost correctness of your decider.

> 
> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>  > I don't think that is the shell game. PO really /has/ an H
>  > (it's trivial to do for this one case) that correctly determines
>  > that P(P) *would* never stop running *unless* aborted.
> 
> Try to show how this DD correctly simulated by any HH ever
> stops running without having its simulation aborted by HH.

And who cares, since you have defined your "correct simulation" to allow 
for just partial simuations, and thus do not indicate non-halting behavior.

> 
> _DD()
> [00001c22] 55         push ebp
> [00001c23] 8bec       mov ebp,esp
> [00001c25] 51         push ecx
> [00001c26] 8b4508     mov eax,[ebp+08]
> [00001c29] 50         push eax      ; push DD 1c22
> [00001c2a] 8b4d08     mov ecx,[ebp+08]
> [00001c2d] 51         push ecx      ; push DD 1c22
> [00001c2e] e80ff7ffff call 00001342 ; call HH
> 
> A {correct simulation} means that each instruction of the
> above x86 machine language of DD is correctly simulated
> by HH and simulated in the correct order.
> 
> In other words the first seven steps of DD correctly simulated
> by HH call HH(DD,DD) to repeat these first seven steps. HH then
> simulates itself simulating DD until this second instance of DD
> calls another HH(DD,DD) to repeat these first seven steps again.

Nope, as after the 7th instruction must be the 8th instruction, which is 
thw Call HH instruction. To meet your definition, the simulation must 
then continue into HH as THAT is the correct behavior of that instruction

So your arguement is totally off track, andyou are failing to meet even 
your own requirements.

> 
> New slave_stack at:10306d
> Begin Local Halt Decider Simulation   Execution Trace Stored at:113075
>   machine   stack     stack     machine    assembly
>   address   address   data      code       language
>   ========  ========  ========  =========  =============
> [00001c22][00113061][00113065] 55         push ebp        ; begin DD
> [00001c23][00113061][00113065] 8bec       mov ebp,esp
> [00001c25][0011305d][00103031] 51         push ecx
> [00001c26][0011305d][00103031] 8b4508     mov eax,[ebp+08]
> [00001c29][00113059][00001c22] 50         push eax         ; push DD
> [00001c2a][00113059][00001c22] 8b4d08     mov ecx,[ebp+08]
> [00001c2d][00113055][00001c22] 51         push ecx         ; push DD
> [00001c2e][00113051][00001c33] e80ff7ffff call 00001342    ; call HH
> New slave_stack at:14da95
> [00001c22][0015da89][0015da8d] 55         push ebp         ; begin DD
> [00001c23][0015da89][0015da8d] 8bec       mov ebp,esp
> [00001c25][0015da85][0014da59] 51         push ecx
> [00001c26][0015da85][0014da59] 8b4508     mov eax,[ebp+08]
> [00001c29][0015da81][00001c22] 50         push eax         ; push DD
> [00001c2a][0015da81][00001c22] 8b4d08     mov ecx,[ebp+08]
> [00001c2d][0015da7d][00001c22] 51         push ecx         ; push DD
> [00001c2e][0015da79][00001c33] e80ff7ffff call 00001342    ; call HH
> Local Halt Decider: Recursive Simulation Detected Simulation Stopped
> 
> The above is the complete proof that DD correctly simulated
> by any HH that can possibly exist never stops running without
> having its simulation aborted by HH (or crashing for OOM error).
> 

But if fails to meet your definition of "Correct Simulation" so your 
argument is just shown to be a LIE.