Re: Can D simulated by H terminate normally? --- Message_ID Provided

On 5/1/2024 7:10 PM, Richard Damon wrote:

On 5/1/24 12:11 PM, olcott wrote:

Until you refine your current non-existant definitions of the terms, you have the problem described.
>

>
I can't have any idea what you are saying until you fill in
all of the details of your baseless claims.
>

 But you refuse to listen.
 Remember, YOU are the one saying you are needing to change the definition from the classical theory, where we have things well defined.
 YOU have decider that H is just whatever C code you want to write for it, and D is the input proved. (which doesn't actually match the Linz or Sipser proof, but fairly close).
 

First of all the code template that I am currently referring
has nothing to do with any decider, it only pertains to a
simulator where H correctly simulates 1 to ∞ steps of D
of each H/D pair specified by the following template.
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 correctly simulated by any H of every H/D pair specified by the above template ever reaches its own line 06 and halts.

With THAT set of definitions we have a lot of options that break your incorrectly assumed results.
 

I augmented the definitions since you posted this reply.

The first method has been discussed here by Flibble. While the final answer he got to doesn't fit the requirements, the first part of the method DOES show that it is possible for an H to simulate to past line 3.
 

It is impossible for D to be correctly simulated by H within the
above definitions that have H as only a simulator and specify
exactly what a correct simulation is.

THe basic idea is that if H(M,d) finds that its simulation of M(d) get to a call to H(M,d) then rather that your idea of just saying it will get stuck and declair the input invalid, since there ARE a number of possible inputs that there is a "correct" answer that H can give to match the behavior of the direct execution of M(d), what H does is fork its simulation into two threads.
 

Pure simulator H has no basis to do that. I am stopping here
you can update this view on this new set of definitions.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer