On 2024-01-11 14:22:34 +0000, olcott said about
"Try and show how D correctly simulated by H reaches its own line 09":

04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: 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 06*

What the correct simulation trace is, and in particular whether it
reaches the line 09, depends on what H does.

Assuming H is a buggy halt decider (i.e., H determines correctly for
some but incorrectly for other inputs whether the conputation ever
halts) that returns false for the specific input D, D, the execution
trace; and also assuming that H correctly traces what it (correctly
or otherwise) simulates:

//// start of simulation of D(D) by H
04 int D(ptr x) //// enter D, x = D
05 {
06 int Halt_Status = H(x, x); //// call H, x == D, returning 0
//// code of H is not simulated
07 if (Halt_Status) //// Halt_Status is 0
09 return Halt_Status; //// return 0
//// end of simulation of D(D) by H

Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-01-12 16:26:52 +0000, olcott said:

On 1/12/2024 2:22 AM, Mikko wrote:

On 2024-01-11 14:22:34 +0000, olcott said about
"Try and show how D correctly simulated by H reaches its own line 09":

04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: 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 06*

What the correct simulation trace is, and in particular whether it
reaches the line 09, depends on what H does.

Mike Terry has confirmed that H does correctly simulate N steps of D.
There is no possible way that any correct simulation of D by any H
that can possibly exist ever reaches line 06 of D.

*This can be confirmed by the source code of D posted above*

Apparently Mike Terry had a different interpretation of "any H that
can possibly exist". What I said is true about some H that is consitent
with the question of OP.

Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 13/01/2024 14:57, olcott wrote:

On 1/13/2024 2:36 AM, Mikko wrote:

On 2024-01-12 16:26:52 +0000, olcott said:

On 1/12/2024 2:22 AM, Mikko wrote:

On 2024-01-11 14:22:34 +0000, olcott said about
"Try and show how D correctly simulated by H reaches its own line 09": >>>>

04 int D(ptr x)
05 {
06�� int Halt_Status = H(x, x);
07�� if (Halt_Status)
08���� HERE: goto HERE;
09�� return Halt_Status;
10 }
11
12 void main()
13 {
14�� H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: 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 06* >>>>

What the correct simulation trace is, and in particular whether it
reaches the line 09, depends on what H does.

Mike Terry has confirmed that H does correctly simulate N steps of D.
There is no possible way that any correct simulation of D by any H
that can possibly exist ever reaches line 06 of D.

*This can be confirmed by the source code of D posted above*

Apparently Mike Terry had a different interpretation of "any H that
can possibly exist". What I said is true about some H that is consitent
with the question of OP.

Mikko

Mike Terry was carefully reporting on the actual behavior
of D correctly simulated by H at the x86 machine code level.
He confirmed that N instructions of D were correctly simulated by H.

After N instructions of D are correctly simulated by H or HH
then H and HH correctly detect a non-halting behavior pattern

the pattern is "correctly spotted", i.e. the computation in question does indeed match the pattern,
but as I pointed out IT IS NOT A NON-HALTING PATTERN...

Mike.

and abort their simulation. HH does this after it has simulated
itself simulating D.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 13/01/2024 08:36, Mikko wrote:

On 2024-01-12 16:26:52 +0000, olcott said:

On 1/12/2024 2:22 AM, Mikko wrote:

On 2024-01-11 14:22:34 +0000, olcott said about
"Try and show how D correctly simulated by H reaches its own line 09":

04 int D(ptr x)
05 {
06�� int Halt_Status = H(x, x);
07�� if (Halt_Status)
08���� HERE: goto HERE;
09�� return Halt_Status;
10 }
11
12 void main()
13 {
14�� H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: 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 06* >>>

What the correct simulation trace is, and in particular whether it
reaches the line 09, depends on what H does.

Mike Terry has confirmed that H does correctly simulate N steps of D.
There is no possible way that any correct simulation of D by any H
that can possibly exist ever reaches line 06 of D.

*This can be confirmed by the source code of D posted above*

Apparently Mike Terry had a different interpretation of "any H that
can possibly exist". What I said is true about some H that is consitent
with the question of OP.

I don't recall ever commenting on the phrase "any H that can possibly exist". It's one of those
"duffer" phrases that I wouldn't even bother trying to pin down with PO. Like his "What is the
/correct simulation trace/ of D(D) /by H/ ?"

PO loves to grab little quotations from people, and then present them without the surrounding
context so that he can make out that people are supporting his position when they are not. It's one
of his ways of trying to swat away legitimate criticisms of his arguments without addressing them.

Anyway, FTR what I said was that AFAICT the x86utm simulation code does indeed correctly simulate
individual x86 instructions. For example if it simulates a "push eax" instruction, the current
(virtual) eax register gets stored in virtual memory at the correct location on the stack, and
(virtual) esp register is correctly decremented, and (virtual) eip is correctly incremented etc.
etc.. That functionality was not written by PO, and while it is tedious it is not "difficult" code,
and is all within . Also AFAICT PO's own x86utm "step simulation" primitive appears to be correctly
simulated and to nest correctly. So if H simulates (say) 427 steps of D(D), AFAICT those 427 steps
are simulated correctly.

I also made it clear that if after those 427 steps, H decides it's seen enough, and stops simulating
and returns "non-halting" then since D(D) does in fact halt, that means that H's /termination
analysis/ code is wonky. (But still, the 427 simulation steps were done correctly.)


Regards,
Mike.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 1/13/24 2:17 PM, olcott wrote:

On 1/13/2024 12:25 PM, Mike Terry wrote:

On 13/01/2024 08:36, Mikko wrote:

On 2024-01-12 16:26:52 +0000, olcott said:

On 1/12/2024 2:22 AM, Mikko wrote:

On 2024-01-11 14:22:34 +0000, olcott said about
"Try and show how D correctly simulated by H reaches its own line 09": >>>>>

04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: 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 06*

What the correct simulation trace is, and in particular whether it
reaches the line 09, depends on what H does.

Mike Terry has confirmed that H does correctly simulate N steps of D.
There is no possible way that any correct simulation of D by any H
that can possibly exist ever reaches line 06 of D.

*This can be confirmed by the source code of D posted above*

Apparently Mike Terry had a different interpretation of "any H that
can possibly exist". What I said is true about some H that is consitent
with the question of OP.

I don't recall ever commenting on the phrase "any H that can possibly
exist".  It's one of those "duffer" phrases that I wouldn't even
bother trying to pin down with PO.  Like his "What is the /correct
simulation trace/ of D(D) /by H/ ?"

PO loves to grab little quotations from people, and then present them
without the surrounding context so that he can make out that people
are supporting his position when they are not.  It's one of his ways
of trying to swat away legitimate criticisms of his arguments without
addressing them.

Anyway, FTR what I said was that AFAICT the x86utm simulation code
does indeed correctly simulate individual x86 instructions.  For
example if it simulates a "push eax" instruction, the current
(virtual) eax register gets stored in virtual memory at the correct
location on the stack, and (virtual) esp register is correctly
decremented, and (virtual) eip is correctly incremented etc. etc..
That functionality was not written by PO, and while it is tedious it
is not "difficult" code, and is all within .  Also AFAICT PO's own
x86utm "step simulation" primitive appears to be correctly simulated
and to nest correctly.  So if H simulates (say) 427 steps of D(D),
AFAICT those 427 steps are simulated correctly.

I also made it clear that if after those 427 steps, H decides it's
seen enough, and stops simulating and returns "non-halting" then since
D(D) does in fact halt,

01 int D(ptr x)  // pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }

That means that you are using the strawman deception and changing the
subject away from D correctly simulated by H that cannot possibly reach
its own line 06 and terminate normally in 1 to infinity steps of correct simulation.

Do you understand that int sum(int y, int x){return x + y;}
cannot correctly return 7 for sum(3,2) ???

A decider must report on its actual input and is not allowed
to report on anything else. The directly executed
*D(D) IS NOT A FREAKING INPUT TO H*

No, a decider must report on a PROPERTY of its actual input.

And the behavior of the direct execution of D(D) is such a property.

You are just showing your fundamental lack of understanding of what you
are talking about.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-01-13 19:17:08 +0000, olcott said:

On 1/13/2024 12:25 PM, Mike Terry wrote:

On 13/01/2024 08:36, Mikko wrote:

On 2024-01-12 16:26:52 +0000, olcott said:

On 1/12/2024 2:22 AM, Mikko wrote:

On 2024-01-11 14:22:34 +0000, olcott said about
"Try and show how D correctly simulated by H reaches its own line 09": >>>>>

04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: 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 06* >>>>>

What the correct simulation trace is, and in particular whether it
reaches the line 09, depends on what H does.

Mike Terry has confirmed that H does correctly simulate N steps of D.
There is no possible way that any correct simulation of D by any H
that can possibly exist ever reaches line 06 of D.

*This can be confirmed by the source code of D posted above*

Apparently Mike Terry had a different interpretation of "any H that
can possibly exist". What I said is true about some H that is consitent
with the question of OP.

I don't recall ever commenting on the phrase "any H that can possibly
exist".  It's one of those "duffer" phrases that I wouldn't even bother
trying to pin down with PO.  Like his "What is the /correct simulation
trace/ of D(D) /by H/ ?"

PO loves to grab little quotations from people, and then present them
without the surrounding context so that he can make out that people are
supporting his position when they are not.  It's one of his ways of
trying to swat away legitimate criticisms of his arguments without
addressing them.

Anyway, FTR what I said was that AFAICT the x86utm simulation code does
indeed correctly simulate individual x86 instructions.  For example if
it simulates a "push eax" instruction, the current (virtual) eax
register gets stored in virtual memory at the correct location on the
stack, and (virtual) esp register is correctly decremented, and
(virtual) eip is correctly incremented etc. etc..  That functionality
was not written by PO, and while it is tedious it is not "difficult"
code, and is all within .  Also AFAICT PO's own x86utm "step
simulation" primitive appears to be correctly simulated and to nest
correctly.  So if H simulates (say) 427 steps of D(D), AFAICT those 427
steps are simulated correctly.

I also made it clear that if after those 427 steps, H decides it's seen
enough, and stops simulating and returns "non-halting" then since D(D)
does in fact halt,

01 int D(ptr x) // pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }

That means that you are using the strawman deception and changing the
subject away from D correctly simulated by H that cannot possibly reach
its own line 06 and terminate normally in 1 to infinity steps of correct simulation.

Do you understand that int sum(int y, int x){return x + y;}
cannot correctly return 7 for sum(3,2) ???

A decider must report on its actual input and is not allowed
to report on anything else. The directly executed
*D(D) IS NOT A FREAKING INPUT TO H*

Yes it is. A call H(T, I) tells H everything about T(I), so T(I) is
given in the input. If T == D and I == D then T(I) == D(D) and
is given in the input.

Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)