Re: Every D(D) simulated by H presents non-halting behavior to H ###

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.

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.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer