Re: Proof that executed HH(DD,DD) and simulated HH(DD,DD) simulate DD correctly -- Mike Terry

On 6/9/2024 2:31 AM, Mikko wrote:

On 2024-06-08 12:25:35 +0000, olcott said:
 

On 6/8/2024 12:43 AM, Mikko wrote:

On 2024-06-07 13:49:09 +0000, olcott said:
 

On 6/7/2024 12:49 AM, Mikko wrote:

On 2024-06-06 15:06:22 +0000, olcott said:

<Professor Sipser agreed>
   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.
</Professor Sipser agreed>
 // Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
   if (H(x, x))
     HERE: goto HERE;
}
 People here that are experts in the C programming language know that
*P correctly simulated by H cannot possibly stop running unless aborted*
yet lie about this or to try to get away with the strawman deception
CHANGE-THE-SUBJECT fake rebuttal.

 People here who have recently followed these discussions know that "P
correctly simulated by H cannot possibly stop running unless aborted"
does not confirm or contradict anything Linz and Strachey have said.

 When P correctly simulated by H meets this criteria
   If simulating halt decider H correctly simulates its input P
   until H correctly determines that its simulated P would never
   stop running unless aborted then

 Still unproven whther P ever meets those criteria, in particular
the last "correctly".
 

 That you lack the mandatory prerequisite knowledge to understand
that this is correct provided zero evidence that this is incorrect.

 Doesn't matter. Much less understanding is needed to see that you have
not proven that P ever meets the criteria agreed by Siplser. Equally
clear is that you have not proven that P never meets those criteria.
 

I incorporate by reference
(a) The x86 language
(b) The notion of an x86 emulator
 (c) I provide this complete function
 void DDD(int (*x)())
{
   HH(x, x);
}
 _DDD()
[00001de2] 55         push ebp
[00001de3] 8bec       mov ebp,esp
[00001de5] 8b4508     mov eax,[ebp+08]
[00001de8] 50         push eax         ; push DD
[00001de9] 8b4d08     mov ecx,[ebp+08]
[00001dec] 51         push ecx         ; push DD
[00001ded] e890f5ffff call 00001382    ; call HH
[00001df2] 83c408     add esp,+08
[00001df5] 5d         pop ebp
[00001df6] c3         ret
Size in bytes:(0021) [00001df6]
 Then I state that No DDD correctly emulated by any
x86 emulator H can possibly reach its own [00001df6]
instruction.
 To anyone having this mandatory prerequisite knowledge
(perhaps not you) every x86 emulation of DDD by any
x86 emulator H continually repeats the first seven lines
of DDD until it crashes due to out-of-memory error.

 OK, but insufficient.
 

 Try and show what is missing.