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

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.