Re: Can someone please verify the execution trace of this?

On 21.05.2024 05:58, olcott wrote:

[...]
 
I cannot provide the definition for H because I am asking about
the behavior of D simulated by H for the infinite set of H/D pairs.
 
H is required to correctly simulate 1 to N steps of D and this
may or may not involve H simulating itself simulating D in recursive
simulation.
 
I have two fully operational versions of H that run under Windows
and Linux. I am not asking about those.
 
H uses an x86 emulator to emulate the machine code of D and
H is capable of emulating itself emulating D.
 
typedef int (*ptr)();  // ptr is pointer to int function
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 }
 
Correct simulation requires correctly emulating the x86 instructions
of D in the order specified by the machine code of D and may include
correctly emulating the x86 instructions of H in the order specified
by the machine code of H.
 
I need to have experts in these two forums verify that no D correctly
simulated by *pure function* H can possibly reach its own final state
at line 06 and halt in N steps of correct simulation.

We're not doing your homework for you. Please provide or elaborate
a rationale or explanation for your claim, thought, or theorem, and
folks here may be able and willing to support you, or show you any
possibly existing deficiencies.

(Fred Zwarts has, with slightly different wording, already given this
hint to you just 24 hours ago. I notice he just repeated that post.)

Just ignoring the replies thus far and stupidly repeating your code
is likely considered pathological behavior and may not be honored by
the audience.

If you don't understand that it's probably better to just hold your
breath until you turn blue instead of repeating your post without
generating any new insights (on both sides).

https://en.wikipedia.org/wiki/Pure_function#
 
I thought it was categorically impossible then Richard found a loophole
using static data. This new *pure function* requirement eliminates that
loophole.