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

On 5/22/2024 2:39 AM, Mikko wrote:

On 2024-05-21 13:54:09 +0000, olcott said:

You are asking for the definition of correct simulation
that I have been providing for quite a while recently.

 That was not my main intent. I wanted to know why your
statement
 

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.

 exludes every unsimulated or incorrectly simulated D?
 

That sounds like Richard that assumed that incorrect answers are OK
unless I specifically say that incorrect answers are not OK.
On 5/19/2024 12:17 PM, Richard Damon wrote:
 > On 5/19/24 9:59 AM, olcott wrote:
 >> Richard has stated that he thinks that an example of
 >> {D never simulated by H} ∈ {every D simulated by H}
 >
 > No, the H that didn't simulate its input shows that
 > *once you allow H to not be required to be correct*,
 > that we can then have a trivial function that is
 > "just as correct" (since wrong answers were allowed).

A c function is correctly simulated when its machine language
instructions are emulated with an x86 emulator in the order
that they are specified by the x86 machine language of this
c function.

 Does "its machine language instructions" mean all executed instructions
until the progam terminates? Or from the start of the program until
there is no reason to continue? Or from some point to some other point?
 

It means that 1 to N instructions of D are correctly simulated
by pure function H. Because D correctly simulated by H remains
stuck in recursive simulation D cannot possibly reach is own
line 06 and halt.

For non-terminating functions we can only correctly
simulate N machine language instructions.

 But does you definition regard that partial simulation as "correct
simulation"?
 

When 1 to 2^64 instructions of D are correctly simulated by H
it becomes clear that for every H/D pair of the infinite set
of H/D pairs D correctly simulated by H remains stuck in recursive
simulation.

For the H/D pair we can simulate 1 to N instructions of D that
results in 0 to M recursive simulations of H simulating itself
simulating D.

 But is this kind of recursive simulation "correc"? Does "correct"
apply to ("correctly" or otherwise) simulated simulations? Does
correctness of simulation of simulation depend on the oorrectness
of simulated simulation?
 

typedef int (*ptr)();  // ptr is pointer to int function in C
00       int H(ptr p, ptr i);
01       int D(ptr p)
02       {
03         int Halt_Status = H(p, p);
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       }
When talking about an infinite set of H/D pairs...
A c function is correctly simulated when its machine language
instructions are emulated with an x86 emulator in the order that
they are specified by the x86 machine language of this c function.
For terminating inputs the input is simulated until termination.
This applies to every H/D pair of the infinite set of H/D pairs
matching the above template:
Every D correctly simulated by pure by function H remains stuck in
recursive simulation and can never reach its own line 06 and halt.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer