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

On 5/5/24 2:43 PM, olcott wrote:

On 5/5/2024 12:22 PM, Richard Damon wrote:

On 5/5/24 1:02 PM, olcott wrote:

The x86utm operating system: https://github.com/plolcott/x86utm enables
one C function to execute another C function in debug step mode.
Simulating Termination analyzer H simulates the x86 machine code of its
input (using libx86emu) in debug step mode until it correctly matches a
correct non-halting behavior pattern proving that its input will never
stop running unless aborted.

>
Except that the pattern it uses is incorrect, since H(D,D) using this "pattern" says that D(D) will not halt, where, when main calls D(D), it does return/halt, so H is just incorrect.
>

 We haven't ever reach that point where the patterns are detailed yet.
You are saying the the details are wrong on the basis of not seeing
them.

Except that there CAN'T be a non-halting pattern in D(D) since it Halts, as will the UTM simulation of it.
So, ANY initial "N" steps of H's simulation of D can't be a pattern that will always be non-halting.
Also, you have only shown a very few patterns in the past that you have tried to use in the past, and none of them that are in D are correct.

 

>

>
Can D correctly simulated by H terminate normally?
00 int H(ptr x, ptr x)  // ptr is pointer to int function
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 }
>
*Execution Trace*
Line 11: main() invokes H(D,D);
>
*keeps repeating* (unless aborted)
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.

>
Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed that it would be trivial to show the error in the proof, but hasn't done it, showing that he doesn't actually have an answer to the refutation, and thus by just repeating a statment that is know to at least potentially have a problem as if it was just clearly true is just a pathological lie.
>

>
The above execution trace proves that (for every H/D pair of the
infinite set of H/D pairs) each D(D) simulated by the H that this D(D)
calls cannot possibly reach past its own line 03.

>
Except that the proof shows that you are not smart enough to think of some of the ways arround the problem (even though those methods were discussed a long time back)
>

 It is no longer possible to intentionally mismatch the elements
of H/D pairs: *The D simulated by the H that this D calls*
I am stopping on this point until this point is fully resolved

Right, and that is what I did.
Now YOU need to remember that H needs to simulate the H that this D calls too, and not some other H.

 If you are claiming that you have some top secret proof that shows
the above execution trace is incorrect I am taking this as the empty
claims of evidence of election fraud that no one has ever seen.

Yes, since your trace STOPS at the call to H instruction, and then uses faulty logic to proceed past it that claims that NO H that can possibly be written can simulate past that point.
That is proven incorrecdt.

 

>
*Shown by ordinary software engineering* When the directly executed
H(D,D) aborts simulating its input then all of the nested simulations
(if any) immediately totally stop running and no simulated H ever
returns any value to any simulated D.
>

>
Right, but that doesn't change the behavor of the correctly and completely simulated input or the direct execution of the program descirbed.
>

 From this we can definitely know that every D(D) of the infinite set
of H/D pairs where this D(D) is simulated by the H that this D(D) calls
that this D(D) presents non-halting behavior to this H.

>
Nope. And the conclusion doesn't even follow from the incorrect premise.
>
>

>
*Termination Analyzer H is Not Fooled by Pathological Input D*
https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>

>
Just LIES.