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.
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.
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.
*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.
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.
*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
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.
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)
Mismatching the elements of the infinite set of H/D pairs has
been unequivocally accounted for.
*The above execution trace proves the behavior of each D simulated by*
*each H of the elements of the infinite set of H/D pairs where this D*
*calls that 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.
*I will perpetually hound you for this evidence*
*I will perpetually hound you for this evidence*
*I will perpetually hound you for this evidence*
This same method worked on an election denier, they deleted all
of their claims of election fraud and left.
*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.
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed that
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. >>>>
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)
The above execution trace proves the behavior of each D simulated by
each H of the elements of the infinite set of H/D pairs where this D
calls that H.
Nope, your problem is you stop simulating at the call to H and then
resort to incorrect logic to try to figure out what happens next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
Elements of this set of H/D pairs simulate from 1 to infinite steps of D
and each one of them does this in an infinite number of different ways.
There are an infinite number of different ways for H to simulate
1 step of D.
You are just stuck in the wrong ideas about 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.
But not "Top Secret" as openly published here, and it was using ideas
that have been discussed here in the past.
*I will perpetually hound you for this evidence*
*I will perpetually hound you for this evidence*
*I will perpetually hound you for this evidence*
By LYING that it was not presented.
This same method worked on an election denier, they deleted all
of their claims of election fraud and left.
So, are you willing to put up or shut up?
If I can show you how to write a valid C program H that can correctly
simulates this D above (that calls my H), will you abandon your
repeated claims that you can do this?
*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.
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed that
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. >>>>
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)
The above execution trace proves the behavior of each D simulated by
each H of the elements of the infinite set of H/D pairs where this D
calls that H.
Nope, your problem is you stop simulating at the call to H and then
resort to incorrect logic to try to figure out what happens next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
H that simulates the D that calls H(D,D) will simulate to
1 ∞ steps of D.
When H stops simulating D then the simulated H that D calls
also immediately stops because the executed H(D,D) that was
simulating D(D) was also simulating the H(D,D) that D(D)
calls as a part of its simulation of D(D).
You are just stuck in the wrong ideas about 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.
But not "Top Secret" as openly published here, and it was using ideas
that have been discussed here in the past.
*I will perpetually hound you for this evidence*
*I will perpetually hound you for this evidence*
*I will perpetually hound you for this evidence*
By LYING that it was not presented.
This same method worked on an election denier, they deleted all
of their claims of election fraud and left.
So, are you willing to put up or shut up?
If I can show you how to write a valid C program H that can correctly
simulates this D above (that calls my H), will you abandon your
repeated claims that you can do this?
*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.
On 5/5/2024 4:13 PM, Richard Damon wrote:
So, are you willing to put up or shut up?
An election denier knew that I beat them.
They deleted all of their election denial replies and left.
If I can show you how to write a valid C program H that can correctly
simulates this D above (that calls my H), will you abandon your
repeated claims that you can do this?
On 5/5/2024 4:56 PM, Richard Damon wrote:
On 5/5/24 5:30 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D simulated by >>>>> each H of the elements of the infinite set of H/D pairs where this D >>>>> calls that H.
Nope, your problem is you stop simulating at the call to H and then
resort to incorrect logic to try to figure out what happens next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
Elements of this set of H/D pairs simulate from 1 to infinite steps
of D and each one of them does this in an infinite number of
different ways.
(this is wrong, as EACH H only simulates its one D one way, so each
one doesn't simulate in an infinite number of ways, but I think you
are just failing at grammer here
There are an infinite number of different ways for H to simulate
1 step of D.
So?
*Your system clock is off you responded to my 5:30 post at 4:56*
The TWO methods I posted still follow that description and show how H
can simulate past the point that you say NO H can get past,
*This has already been proven to be dishonest*
On 5/1/2024 7:28 PM, Richard Damon wrote:
On 5/1/24 11:51 AM, olcott wrote:
*I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*
Every D simulated by H that cannot possibly stop running unless
aborted by H does specify non-terminating behavior to H. When
H aborts this simulation that does not count as D halting.
Which is just meaningless gobbledygook by your definitions.
It means that
int H(ptr m, ptr d) {
return 0;
}
is always correct, because THAT H can not possible simulate
the input to the end before it aborts it, and that H is all
that that H can be, or it isn't THAT H.
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
Can only be interpreted to *D NEVER simulated by H*
through dishonestly.
That you repeatedly say you have proof yet do not present
this proof cannot be reasonably construed as truthful.
The pillow guy that keeps asserting there is evidence
of election fraud knowing full well there there is none
is pulling this same scam.
Do you want to live in a Nazi USA because someone is
getting away with your same scam?
On 5/5/2024 6:27 PM, Richard Damon wrote:
On 5/5/24 6:56 PM, olcott wrote:
On 5/5/2024 4:56 PM, Richard Damon wrote:
On 5/5/24 5:30 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D simulated by >>>>>>> each H of the elements of the infinite set of H/D pairs where this D >>>>>>> calls that H.
Nope, your problem is you stop simulating at the call to H and
then resort to incorrect logic to try to figure out what happens
next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
Elements of this set of H/D pairs simulate from 1 to infinite steps
of D and each one of them does this in an infinite number of
different ways.
(this is wrong, as EACH H only simulates its one D one way, so each
one doesn't simulate in an infinite number of ways, but I think you
are just failing at grammer here
There are an infinite number of different ways for H to simulate
1 step of D.
So?
*Your system clock is off you responded to my 5:30 post at 4:56*
No, you don't seem to understand about TIME ZONES.
I guess that is too advanced for you.
USENET posts are in universal time and only translated
in the news reader. That your replies are coming in
before some of my later posts indicates an issue
on your end.
The TWO methods I posted still follow that description and show how
H can simulate past the point that you say NO H can get past,
*This has already been proven to be dishonest*
Nope, you seem to be stuck on the example below, which is not either
of the two methods I showed how to simulate past the call, but showed
how if your statement WAS made to be correct, how it implies a trivial
decider could also be considered correct.
I have mentioned this several times, but I guess you can't understand
basic English.
On 5/1/2024 7:28 PM, Richard Damon wrote:
On 5/1/24 11:51 AM, olcott wrote:
*I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*;
Every D simulated by H that cannot possibly stop running unless
aborted by H does specify non-terminating behavior to H. When
H aborts this simulation that does not count as D halting.
Which is just meaningless gobbledygook by your definitions.
;
It means that
;
int H(ptr m, ptr d) {
return 0;
}
;
is always correct, because THAT H can not possible simulate
the input to the end before it aborts it, and that H is all
that that H can be, or it isn't THAT H.
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
Can only be interpreted to *D NEVER simulated by H*
through dishonestly.
That you repeatedly say you have proof yet do not present
this proof cannot be reasonably construed as truthful.
That you keep on saying I haven't, when I have, and keep on point to a
message talking about something different just shows your totally
ignorance of what you are talking about.
The pillow guy that keeps asserting there is evidence
of election fraud knowing full well there there is none
is pulling this same scam.
Do you want to live in a Nazi USA because someone is
getting away with your same scam?
No, but I won't try to stop him doing the same thing that he does.
Why do you refuse to look at the evidence put before you,
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
On 5/5/2024 5:44 PM, Richard Damon wrote:
On 5/5/24 6:03 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D simulated by >>>>> each H of the elements of the infinite set of H/D pairs where this D >>>>> calls that H.
Nope, your problem is you stop simulating at the call to H and then
resort to incorrect logic to try to figure out what happens next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
H that simulates the D that calls H(D,D) will simulate to
1 ∞ steps of D.
Nope, when your H simulates the call to H(D,D) inside D, your H does
NOT simulated that H, but instead simultes the machine that that
machine would be simulating.
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
The 1st H simulates 1 steps of D
The 2nd H simulates 2 steps of D
The 3rd H simulates 3 steps of D
...
The 5,000,000,000 H simulates 5,000,000,000 steps of D
...
All the way up to H that simulates ∞ steps of D
None of these D(D) simulated by the H that D(D) calls
ever reach past their own line 03.
On 5/5/2024 5:44 PM, Richard Damon wrote:
On 5/5/24 6:03 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D simulated by >>>>> each H of the elements of the infinite set of H/D pairs where this D >>>>> calls that H.
Nope, your problem is you stop simulating at the call to H and then
resort to incorrect logic to try to figure out what happens next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
H that simulates the D that calls H(D,D) will simulate to
1 ∞ steps of D.
Nope, when your H simulates the call to H(D,D) inside D, your H does
NOT simulated that H, but instead simultes the machine that that
machine would be simulating.
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
On 5/5/2024 5:44 PM, Richard Damon wrote:
On 5/5/24 6:03 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D simulated by >>>>> each H of the elements of the infinite set of H/D pairs where this D >>>>> calls that H.
Nope, your problem is you stop simulating at the call to H and then
resort to incorrect logic to try to figure out what happens next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
H that simulates the D that calls H(D,D) will simulate to
1 ∞ steps of D.
Nope, when your H simulates the call to H(D,D) inside D, your H does
NOT simulated that H, but instead simultes the machine that that
machine would be simulating.
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
The 1st H simulates 1 steps of D
The 2nd H simulates 2 steps of D
The 3rd H simulates 3 steps of D
...
The 5,000,000,000 H simulates 5,000,000,000 steps of D
...
All the way up to H that simulates ∞ steps of D
None of these D(D) simulated by the H that D(D) calls
ever reach past their own line 03.
On 5/5/2024 7:47 PM, Richard Damon wrote:
On 5/5/24 8:35 PM, olcott wrote:
On 5/5/2024 5:44 PM, Richard Damon wrote:
On 5/5/24 6:03 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D simulated by >>>>>>> each H of the elements of the infinite set of H/D pairs where this D >>>>>>> calls that H.
Nope, your problem is you stop simulating at the call to H and
then resort to incorrect logic to try to figure out what happens
next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
H that simulates the D that calls H(D,D) will simulate to
1 ∞ steps of D.
Nope, when your H simulates the call to H(D,D) inside D, your H does
NOT simulated that H, but instead simultes the machine that that
machine would be simulating.
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
So, what does an infinite set of programs and an infinte set of inputs
do?
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
The 1st H simulates 1 steps of D
The 2nd H simulates 2 steps of D
The 3rd H simulates 3 steps of D
...
The 5,000,000,000 H simulates 5,000,000,000 steps of D
...
All the way up to H that simulates ∞ steps of D
None of these D(D) simulated by the H that D(D) calls
ever reach past their own line 03.
If you don't run each of those H's individually on its D, what else do
you mean to do?
When we can directly see that every element of an infinite set
has a property of never reaching past its own line 03 then we
know that no D(D) ever reaches its own line 06 and halts.
From this we know that every input D(D) that calls H(D,D) and
is simulated by H specifies non halting behavior to H(D,D).
I think you need to figure out how your computation model actua;lly
works,
It seems to be just a bunch of gobbledygook to me.
It seems about as bad as WM and his dark numbers.
On 5/5/2024 7:47 PM, Richard Damon wrote:
On 5/5/24 8:35 PM, olcott wrote:
Your system clock is still off.
On 5/5/2024 6:27 PM, Richard Damon wrote:
On 5/5/24 6:56 PM, olcott wrote:
On 5/5/2024 4:56 PM, Richard Damon wrote:
On 5/5/24 5:30 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D simulated by >>>>>>> each H of the elements of the infinite set of H/D pairs where this D >>>>>>> calls that H.
Nope, your problem is you stop simulating at the call to H and
then resort to incorrect logic to try to figure out what happens
next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
Elements of this set of H/D pairs simulate from 1 to infinite steps
of D and each one of them does this in an infinite number of
different ways.
(this is wrong, as EACH H only simulates its one D one way, so each
one doesn't simulate in an infinite number of ways, but I think you
are just failing at grammer here
There are an infinite number of different ways for H to simulate
1 step of D.
So?
*Your system clock is off you responded to my 5:30 post at 4:56*
No, you don't seem to understand about TIME ZONES.
I guess that is too advanced for you.
The TWO methods I posted still follow that description and show how
H can simulate past the point that you say NO H can get past,
*This has already been proven to be dishonest*
Nope, you seem to be stuck on the example below, which is not either
of the two methods
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
I showed how to simulate past the call, but showed how if your
statement WAS made to be correct, how it implies a trivial decider
could also be considered correct.
There is no trivial decider that correctly recognizes recursive
simulation and correctly decides these inputs
void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}
void Infinite_Loop()
{
HERE: goto HERE;
}
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
I have mentioned this several times, but I guess you can't understand
basic English.
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
On 5/1/2024 7:28 PM, Richard Damon wrote:
On 5/1/24 11:51 AM, olcott wrote:
*I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*;
Every D simulated by H that cannot possibly stop running unless
aborted by H does specify non-terminating behavior to H. When
H aborts this simulation that does not count as D halting.
Which is just meaningless gobbledygook by your definitions.
;
It means that
;
int H(ptr m, ptr d) {
return 0;
}
;
is always correct, because THAT H can not possible simulate
the input to the end before it aborts it, and that H is all
that that H can be, or it isn't THAT H.
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
Can only be interpreted to *D NEVER simulated by H*
through dishonestly.
That you repeatedly say you have proof yet do not present
this proof cannot be reasonably construed as truthful.
That you keep on saying I haven't, when I have,
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
and keep on point to a message talking about something different just
shows your totally ignorance of what you are talking about.
The pillow guy that keeps asserting there is evidence
of election fraud knowing full well there there is none
is pulling this same scam.
Do you want to live in a Nazi USA because someone is
getting away with your same scam?
No, but I won't try to stop him doing the same thing that he does.
Why do you refuse to look at the evidence put before you,
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
but instead just insist, like he does, that you must be right without
giving any real evidence.
You both keep repeating the same disproven "facts".
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
He actually has better grounds, as a lack of evidence showing fraud is
not actually proof that there was none, it is a much more complicated
"proof" that things were ok.
In your case, you need to ignore the simple facts presented before you
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
for you to keep on making your false claims. YOU have no defense that
no proof has been shown, you just ignore it saying it can't be right,
because you know what the truth is, because you have gaslighted yourself.
On 5/5/2024 8:36 PM, Richard Damon wrote:
On 5/5/24 8:53 PM, olcott wrote:
On 5/5/2024 5:44 PM, Richard Damon wrote:
On 5/5/24 6:03 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D simulated by >>>>>>> each H of the elements of the infinite set of H/D pairs where this D >>>>>>> calls that H.
Nope, your problem is you stop simulating at the call to H and
then resort to incorrect logic to try to figure out what happens
next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
H that simulates the D that calls H(D,D) will simulate to
1 ∞ steps of D.
Nope, when your H simulates the call to H(D,D) inside D, your H does
NOT simulated that H, but instead simultes the machine that that
machine would be simulating.
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
The 1st H simulates 1 steps of D
The 2nd H simulates 2 steps of D
The 3rd H simulates 3 steps of D
...
The 5,000,000,000 H simulates 5,000,000,000 steps of D
...
All the way up to H that simulates ∞ steps of D
None of these D(D) simulated by the H that D(D) calls
ever reach past their own line 03.
And none of these have anything thing to do with your H, what does it
have to do with it?
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
I AM NOT TALKING ABOUT MY H I AM TALKING ABOUT THE ABOVE H/D PAIRS
Question, do these H actually simulate the instructions of the H that
D calls, or not?
Why does my second example of how to build an H in the post you refuse
to answer no handle this case?
If these H are built by that template, there will be a point where the
H that simulates some number of steps of D and H will find it reaches
the point where H returns to D, which you say is impossible, thus your
logic is wrong.
Prove me wrong, as I have proved you wrong (and not be refuted).
On 5/5/2024 9:11 PM, Richard Damon wrote:
On 5/5/24 9:26 PM, olcott wrote:
On 5/5/2024 6:27 PM, Richard Damon wrote:
On 5/5/24 6:56 PM, olcott wrote:
On 5/5/2024 4:56 PM, Richard Damon wrote:
On 5/5/24 5:30 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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. >>>>>>>>>>
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)
The above execution trace proves the behavior of each D
simulated by
each H of the elements of the infinite set of H/D pairs where >>>>>>>>> this D
calls that H.
Nope, your problem is you stop simulating at the call to H and >>>>>>>> then resort to incorrect logic to try to figure out what happens >>>>>>>> next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
Elements of this set of H/D pairs simulate from 1 to infinite
steps of D and each one of them does this in an infinite number
of different ways.
(this is wrong, as EACH H only simulates its one D one way, so
each one doesn't simulate in an infinite number of ways, but I
think you are just failing at grammer here
There are an infinite number of different ways for H to simulate >>>>>>> 1 step of D.
So?
*Your system clock is off you responded to my 5:30 post at 4:56*
No, you don't seem to understand about TIME ZONES.
I guess that is too advanced for you.
USENET posts are in universal time and only translated
in the news reader. That your replies are coming in
before some of my later posts indicates an issue
on your end.
What makes you think that time stamps are in Universal Time.
Your posts date stamp for this message is:
Sun, 5 May 2024 20:26:15 -0500
Indicating it was sent at 8:26:15 PM by your local clock which is 5
hours behind GMT.
My news reader, when I replied, converted that time to MY local time
zone, which is -0400
As to order changing, it isn't unusual for messages posted from
different servers to get to places with differing speeds.
I am not sure how you think MY postes going FAST is an issue. If my
posts are passing your posts, then it must be your posts are SLOW
Unless you think someone on usenet has developed a time traveling
gateway.
Or, do you think that I have some special connections where I can get
your posts before you make them.
I check new posts on the basis of those that come up
last in time/stamp order. Your new posts are coming
up before several of my own posts that came after.
The TWO methods I posted still follow that description and show
how H can simulate past the point that you say NO H can get past,
*This has already been proven to be dishonest*
Nope, you seem to be stuck on the example below, which is not either
of the two methods I showed how to simulate past the call, but
showed how if your statement WAS made to be correct, how it implies
a trivial decider could also be considered correct.
I have mentioned this several times, but I guess you can't
understand basic English.
On 5/1/2024 7:28 PM, Richard Damon wrote:
On 5/1/24 11:51 AM, olcott wrote:
*I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*;
Every D simulated by H that cannot possibly stop running unless >>>>> >> aborted by H does specify non-terminating behavior to H. When
H aborts this simulation that does not count as D halting.
Which is just meaningless gobbledygook by your definitions.
;
It means that
;
int H(ptr m, ptr d) {
return 0;
}
;
is always correct, because THAT H can not possible simulate
the input to the end before it aborts it, and that H is all
that that H can be, or it isn't THAT H.
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
Can only be interpreted to *D NEVER simulated by H*
through dishonestly.
That you repeatedly say you have proof yet do not present
this proof cannot be reasonably construed as truthful.
That you keep on saying I haven't, when I have, and keep on point to
a message talking about something different just shows your totally
ignorance of what you are talking about.
The pillow guy that keeps asserting there is evidence
of election fraud knowing full well there there is none
is pulling this same scam.
Do you want to live in a Nazi USA because someone is
getting away with your same scam?
No, but I won't try to stop him doing the same thing that he does.
Why do you refuse to look at the evidence put before you,
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
On 5/5/2024 10:08 PM, Richard Damon wrote:
On 5/5/24 10:33 PM, olcott wrote:
On 5/5/2024 6:27 PM, Richard Damon wrote:
On 5/5/24 6:56 PM, olcott wrote:
On 5/5/2024 4:56 PM, Richard Damon wrote:
On 5/5/24 5:30 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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. >>>>>>>>>>
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)
The above execution trace proves the behavior of each D
simulated by
each H of the elements of the infinite set of H/D pairs where >>>>>>>>> this D
calls that H.
Nope, your problem is you stop simulating at the call to H and >>>>>>>> then resort to incorrect logic to try to figure out what happens >>>>>>>> next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
Elements of this set of H/D pairs simulate from 1 to infinite
steps of D and each one of them does this in an infinite number
of different ways.
(this is wrong, as EACH H only simulates its one D one way, so
each one doesn't simulate in an infinite number of ways, but I
think you are just failing at grammer here
There are an infinite number of different ways for H to simulate >>>>>>> 1 step of D.
So?
*Your system clock is off you responded to my 5:30 post at 4:56*
No, you don't seem to understand about TIME ZONES.
I guess that is too advanced for you.
The TWO methods I posted still follow that description and show
how H can simulate past the point that you say NO H can get past,
*This has already been proven to be dishonest*
Nope, you seem to be stuck on the example below, which is not either
of the two methods
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
I showed how to simulate past the call, but showed how if your
statement WAS made to be correct, how it implies a trivial decider
could also be considered correct.
There is no trivial decider that correctly recognizes recursive
simulation and correctly decides these inputs
My trivial decider decided all of them as non-halting.
Proving that your trivial decider is shit because it got factorial wrong.
now, since D(D) Halts, just like factorial(5), why do you say that
H(D,D) is correct to say it doesn't?
void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}
void Infinite_Loop()
{
HERE: goto HERE;
}
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
I have mentioned this several times, but I guess you can't
understand basic English.
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
And I'bve told you what you need to say to get that.
If you are so sure I didn't, it doesn't cost you anything to make the
promise.
If you aren't sure, you need to admit that you claim things without
actually knowing them, and promise to stop doing that.
If you can't, then you need to suffer the consequences of your actions.
On 5/1/2024 7:28 PM, Richard Damon wrote:
On 5/1/24 11:51 AM, olcott wrote:
*I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*;
Every D simulated by H that cannot possibly stop running unless >>>>> >> aborted by H does specify non-terminating behavior to H. When
H aborts this simulation that does not count as D halting.
Which is just meaningless gobbledygook by your definitions.
;
It means that
;
int H(ptr m, ptr d) {
return 0;
}
;
is always correct, because THAT H can not possible simulate
the input to the end before it aborts it, and that H is all
that that H can be, or it isn't THAT H.
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
Can only be interpreted to *D NEVER simulated by H*
through dishonestly.
That you repeatedly say you have proof yet do not present
this proof cannot be reasonably construed as truthful.
That you keep on saying I haven't, when I have,
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
No, I suspect most people who care know what my comment was, and are
enjoyiing seeing you squirm.
and keep on point to a message talking about something different
just shows your totally ignorance of what you are talking about.
The pillow guy that keeps asserting there is evidence
of election fraud knowing full well there there is none
is pulling this same scam.
Do you want to live in a Nazi USA because someone is
getting away with your same scam?
No, but I won't try to stop him doing the same thing that he does.
Why do you refuse to look at the evidence put before you,
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
They may already know where the message was.
but instead just insist, like he does, that you must be right
without giving any real evidence.
You both keep repeating the same disproven "facts".
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
People know who the liar is, and it isn't me.
He actually has better grounds, as a lack of evidence showing fraud
is not actually proof that there was none, it is a much more
complicated "proof" that things were ok.
In your case, you need to ignore the simple facts presented before you
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
This is the cost of you asserting facts without basis.
for you to keep on making your false claims. YOU have no defense
that no proof has been shown, you just ignore it saying it can't be
right, because you know what the truth is, because you have
gaslighted yourself.
On 5/5/2024 10:03 PM, Richard Damon wrote:
On 5/5/24 10:42 PM, olcott wrote:
On 5/5/2024 7:47 PM, Richard Damon wrote:
On 5/5/24 8:35 PM, olcott wrote:
On 5/5/2024 5:44 PM, Richard Damon wrote:
On 5/5/24 6:03 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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. >>>>>>>>>>
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)
The above execution trace proves the behavior of each D
simulated by
each H of the elements of the infinite set of H/D pairs where >>>>>>>>> this D
calls that H.
Nope, your problem is you stop simulating at the call to H and >>>>>>>> then resort to incorrect logic to try to figure out what happens >>>>>>>> next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
H that simulates the D that calls H(D,D) will simulate to
1 ∞ steps of D.
Nope, when your H simulates the call to H(D,D) inside D, your H
does NOT simulated that H, but instead simultes the machine that
that machine would be simulating.
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
So, what does an infinite set of programs and an infinte set of
inputs do?
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
The 1st H simulates 1 steps of D
The 2nd H simulates 2 steps of D
The 3rd H simulates 3 steps of D
...
The 5,000,000,000 H simulates 5,000,000,000 steps of D
...
All the way up to H that simulates ∞ steps of D
None of these D(D) simulated by the H that D(D) calls
ever reach past their own line 03.
Then they aren't doing it right.
When HH(DD,DD) simulates its input and reaches the call
to repeat this process it goes ahead and repeats this
process simulating itself simulating DD. I don't show
the 251 pages of text of HH simulating itself. People
are totally overwhelmed with the halt a page of text
that I do show them.
The hypothetical H(D,D) that I am referring to works
just like the actual HH(DD,DD). When HH simulates HH
simulating DD there is an extra 250 pages of execution
trace that what I show and that is only by simulating
DD twice. 8 lines of DD simulated twice is actually
16000 lines of code.
Simulated once = 8 lines
Simulated twice = 16,000 lines
Simulated thrice = 16,000^2 lines
The above hypothetical H does simulate itself simulating D.
The 5 billion lines of D simulated would take
5,000,000,000 / 8 = 625,000,000 simulations this
251^625,000,000 pages of text to show the full execution trace.
In particular, I suspect they aren't simulation the CALL H instruction
right.
Note, it DOESN'T go directly from "Call H" to a new layer of
simulation of D(D).
I would have to display 251 pages of execution trace
of HH(DD,DD) simulating its input recursively once.
It takes 251^2 pages to simulate it recursively twice.
It takes 251^3 pages to simulate it recursively thrice.
The hypothetical H(D,D) that I am referring to does do this.
Not unless you have somehow redefined what simulation means and not
mentioned that.
This seems to be a common problem with you.
If you don't run each of those H's individually on its D, what else
do you mean to do?
When we can directly see that every element of an infinite set
has a property of never reaching past its own line 03 then we
know that no D(D) ever reaches its own line 06 and halts.
From this we know that every input D(D) that calls H(D,D) and
is simulated by H specifies non halting behavior to H(D,D).
Nope, I described how an H can exist that directly and correctly
simulated ALL o fthe instructions that is sees while simulating D(D)
while doing it RIGHT.
I think you need to figure out how your computation model actua;lly
works,
It seems to be just a bunch of gobbledygook to me.
It seems about as bad as WM and his dark numbers.
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.
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.
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.
On 5/5/2024 4:56 PM, Richard Damon wrote:
On 5/5/24 5:30 PM, olcott wrote:
*Your system clock is off you responded to my 5:30 post at 4:56*
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.
On 5/6/2024 11:37 AM, Mikko wrote:
On 2024-05-05 22:56:04 +0000, olcott said:
On 5/5/2024 4:56 PM, Richard Damon wrote:
On 5/5/24 5:30 PM, olcott wrote:
...
*Your system clock is off you responded to my 5:30 post at 4:56*
According to the headers Richard Damon posted 26 minutes 7 seconds
after olcott. Though this should be irrelevant as the no priority
issue is raised.
Richard's posts showed up before several posts that I had
already posted. This could be a lag on his news server.
I initially assumed that his system clock was off because
I had this same issue before and it was that the local
system clock was off. He never said that he checked his
system clock, he only said that it is auto-set.
On 5/6/2024 5:33 AM, Richard Damon wrote:
On 5/6/24 12:14 AM, olcott wrote:
On 5/5/2024 10:08 PM, Richard Damon wrote:
On 5/5/24 10:33 PM, olcott wrote:
On 5/5/2024 6:27 PM, Richard Damon wrote:
On 5/5/24 6:56 PM, olcott wrote:
On 5/5/2024 4:56 PM, Richard Damon wrote:
On 5/5/24 5:30 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D
simulated by
each H of the elements of the infinite set of H/D pairs where >>>>>>>>>>> this D
calls that H.
Nope, your problem is you stop simulating at the call to H and >>>>>>>>>> then resort to incorrect logic to try to figure out what
happens next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once. >>>>>>>>>
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
Elements of this set of H/D pairs simulate from 1 to infinite >>>>>>>>> steps of D and each one of them does this in an infinite number >>>>>>>>> of different ways.
(this is wrong, as EACH H only simulates its one D one way, so >>>>>>>> each one doesn't simulate in an infinite number of ways, but I >>>>>>>> think you are just failing at grammer here
There are an infinite number of different ways for H to simulate >>>>>>>>> 1 step of D.
So?
*Your system clock is off you responded to my 5:30 post at 4:56*
No, you don't seem to understand about TIME ZONES.
I guess that is too advanced for you.
The TWO methods I posted still follow that description and show >>>>>>>> how H can simulate past the point that you say NO H can get past, >>>>>>>>
*This has already been proven to be dishonest*
Nope, you seem to be stuck on the example below, which is not
either of the two methods
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
I showed how to simulate past the call, but showed how if your
statement WAS made to be correct, how it implies a trivial decider >>>>>> could also be considered correct.
There is no trivial decider that correctly recognizes recursive
simulation and correctly decides these inputs
My trivial decider decided all of them as non-halting.
Proving that your trivial decider is shit because it got factorial
wrong.
Right, just like H is because it gets D(D) wrong.
You persistently ignore my proof that my hypothetical
H(D,D) is specified to work just like my actual HH(DD,DD)
and my actual HH(DD,DD) could (in theory) simulate its input
to a recursive depth of one billion
and the simulated DD would never reach past its own line 03
is your mistake and not my mistake.
It is JUST a correct about factorial as H is about D, which shows that
the issue is the DEFINITION is SHIT (or POOP)
now, since D(D) Halts, just like factorial(5), why do you say that
H(D,D) is correct to say it doesn't?
void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}
void Infinite_Loop()
{
HERE: goto HERE;
}
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
I have mentioned this several times, but I guess you can't
understand basic English.
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
And I'bve told you what you need to say to get that.
If you are so sure I didn't, it doesn't cost you anything to make
the promise.
If you aren't sure, you need to admit that you claim things without
actually knowing them, and promise to stop doing that.
If you can't, then you need to suffer the consequences of your actions. >>>>
On 5/1/2024 7:28 PM, Richard Damon wrote:
On 5/1/24 11:51 AM, olcott wrote:
*I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*;
Every D simulated by H that cannot possibly stop running unless >>>>>>> >> aborted by H does specify non-terminating behavior to H. When >>>>>>> >> H aborts this simulation that does not count as D halting.
Which is just meaningless gobbledygook by your definitions.
;
It means that
;
int H(ptr m, ptr d) {
return 0;
}
;
is always correct, because THAT H can not possible simulate
the input to the end before it aborts it, and that H is all
that that H can be, or it isn't THAT H.
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
Can only be interpreted to *D NEVER simulated by H*
through dishonestly.
That you repeatedly say you have proof yet do not present
this proof cannot be reasonably construed as truthful.
That you keep on saying I haven't, when I have,
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
No, I suspect most people who care know what my comment was, and are
enjoyiing seeing you squirm.
and keep on point to a message talking about something different
just shows your totally ignorance of what you are talking about.
The pillow guy that keeps asserting there is evidence
of election fraud knowing full well there there is none
is pulling this same scam.
Do you want to live in a Nazi USA because someone is
getting away with your same scam?
No, but I won't try to stop him doing the same thing that he does. >>>>>> > Why do you refuse to look at the evidence put before you,
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
They may already know where the message was.
but instead just insist, like he does, that you must be right
without giving any real evidence.
You both keep repeating the same disproven "facts".
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
People know who the liar is, and it isn't me.
He actually has better grounds, as a lack of evidence showing
fraud is not actually proof that there was none, it is a much more >>>>>> complicated "proof" that things were ok.
In your case, you need to ignore the simple facts presented before >>>>>> you
Give me a freaking time/date stamp otherwise
everyone will know that you are lying.
This is the cost of you asserting facts without basis.
for you to keep on making your false claims. YOU have no defense
that no proof has been shown, you just ignore it saying it can't
be right, because you know what the truth is, because you have
gaslighted yourself.
On 5/6/2024 5:34 AM, Richard Damon wrote:
On 5/6/24 12:01 AM, olcott wrote:
On 5/5/2024 10:03 PM, Richard Damon wrote:
On 5/5/24 10:42 PM, olcott wrote:
On 5/5/2024 7:47 PM, Richard Damon wrote:
On 5/5/24 8:35 PM, olcott wrote:
On 5/5/2024 5:44 PM, Richard Damon wrote:
On 5/5/24 6:03 PM, olcott wrote:
On 5/5/2024 4:13 PM, Richard Damon wrote:
On 5/5/24 3:10 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.
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)
The above execution trace proves the behavior of each D
simulated by
each H of the elements of the infinite set of H/D pairs where >>>>>>>>>>> this D
calls that H.
Nope, your problem is you stop simulating at the call to H and >>>>>>>>>> then resort to incorrect logic to try to figure out what
happens next.
I have to usually tell you the exactly same thing several
hundreds of times before you notice that I ever said it once. >>>>>>>>>
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
We are talking about the infinite set of H/D pairs where
D is simulated by the same H that D calls.
H that simulates the D that calls H(D,D) will simulate to
1 ∞ steps of D.
Nope, when your H simulates the call to H(D,D) inside D, your H >>>>>>>> does NOT simulated that H, but instead simultes the machine that >>>>>>>> that machine would be simulating.
I am not talking about my H
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
I will repeat this endlessly to your every post until you get it
So, what does an infinite set of programs and an infinte set of
inputs do?
I am talking about every element of the infinite set of
H/D pairs where D is simulated by the same H that D calls.
The 1st H simulates 1 steps of D
The 2nd H simulates 2 steps of D
The 3rd H simulates 3 steps of D
...
The 5,000,000,000 H simulates 5,000,000,000 steps of D
...
All the way up to H that simulates ∞ steps of D
None of these D(D) simulated by the H that D(D) calls
ever reach past their own line 03.
Then they aren't doing it right.
When HH(DD,DD) simulates its input and reaches the call
to repeat this process it goes ahead and repeats this
process simulating itself simulating DD. I don't show
the 251 pages of text of HH simulating itself. People
are totally overwhelmed with the halt a page of text
that I do show them.
The hypothetical H(D,D) that I am referring to works
just like the actual HH(DD,DD). When HH simulates HH
simulating DD there is an extra 250 pages of execution
trace that what I show and that is only by simulating
DD twice. 8 lines of DD simulated twice is actually
16000 lines of code.
Simulated once = 8 lines
Simulated twice = 16,000 lines
Simulated thrice = 16,000^2 lines
The above hypothetical H does simulate itself simulating D.
The 5 billion lines of D simulated would take
5,000,000,000 / 8 = 625,000,000 simulations this
251^625,000,000 pages of text to show the full execution trace.
In particular, I suspect they aren't simulation the CALL H
instruction right.
Note, it DOESN'T go directly from "Call H" to a new layer of
simulation of D(D).
I would have to display 251 pages of execution trace
of HH(DD,DD) simulating its input recursively once.
It takes 251^2 pages to simulate it recursively twice.
It takes 251^3 pages to simulate it recursively thrice.
The hypothetical H(D,D) that I am referring to does do this.
And why does H use the infinite set of HH's?
H does not use and HH's
My hypothetical H is physically implemented as HH.
I use the simpler name in my paper.
HH(DD,DD) empirically proves that there is no number of recursive
simulations where DD simulated by HH ever reaches past its own line 03.
At least now I see that you had genuine misunderstanding.
Because four other people had a very easy time with this
I did not see how anyone could actually misunderstand.
Not unless you have somehow redefined what simulation means and not
mentioned that.
This seems to be a common problem with you.
If you don't run each of those H's individually on its D, what
else do you mean to do?
When we can directly see that every element of an infinite set
has a property of never reaching past its own line 03 then we
know that no D(D) ever reaches its own line 06 and halts.
From this we know that every input D(D) that calls H(D,D) and
is simulated by H specifies non halting behavior to H(D,D).
Nope, I described how an H can exist that directly and correctly
simulated ALL o fthe instructions that is sees while simulating D(D)
while doing it RIGHT.
I think you need to figure out how your computation model
actua;lly works,
It seems to be just a bunch of gobbledygook to me.
It seems about as bad as WM and his dark numbers.
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything.
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
(the subject)
On 5/6/2024 11:37 AM, Mikko wrote:
On 2024-05-05 22:56:04 +0000, olcott said:
On 5/5/2024 4:56 PM, Richard Damon wrote:
On 5/5/24 5:30 PM, olcott wrote:
...
*Your system clock is off you responded to my 5:30 post at 4:56*
According to the headers Richard Damon posted 26 minutes 7 seconds
after olcott. Though this should be irrelevant as the no priority
issue is raised.
Richard's posts showed up before several posts that I had
already posted. This could be a lag on his news server.
I initially assumed that his system clock was off because
I had this same issue before and it was that the local
system clock was off. He never said that he checked his
system clock, he only said that it is auto-set.
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything.
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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. >>>>
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.
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything.
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there
is no universal set.
Usually the best way to introduce a set of pairs is that first two
sets are specified and then a rule that selects some pairs from
the Cartesian product of those two sets.
In the current case the first set could be the set programs that
take two input values (possibly of some specific type) and returns
a Boolean value, and the second set could be programs that take
one input value (of the same type as the programs in the first set).
Or whatever best serves your purposes.
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything. >>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there
is no universal set.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps of D
and involve zero to ∞ recursive simulations of H simulating itself simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
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 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 simulated by any H ever reaches
its own line 06 and halts. This means that the input to H(D,D) is
ALWAYS non-halting.
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything. >>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there
is no universal set.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps of D
and involve zero to ∞ recursive simulations of H simulating itself simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
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 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 simulated by any H ever reaches
its own line 06 and halts. This means that the input to H(D,D) is
ALWAYS non-halting.
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>> you are talking about. As you don't, your words don't mean anything. >>>>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there >>>>> is no universal set.
This template defines an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
These H/D pairs can be enumerated by the one to ∞ simulated steps of
D and involve zero to ∞ recursive simulations of H simulating itself
simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of many
more simulations that only these.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
In particular since the H as presented is not a pure function,
but uses hidden inputs. If hidden inputs are allowed, it is easy
to construct very different H functions, e.g., H functions for
which the number of steps differ at each simulation level.
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything. >>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there
is no universal set.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps of D
and involve zero to ∞ recursive simulations of H simulating itself simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
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 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 simulated by any H ever reaches
its own line 06 and halts. This means that the input to H(D,D) is
ALWAYS non-halting.
No, it shows that he is just thinking of Nieve set theory, you know,
the one that was proven broken.
Usually the best way to introduce a set of pairs is that first two
sets are specified and then a rule that selects some pairs from
the Cartesian product of those two sets.
In the current case the first set could be the set programs that
take two input values (possibly of some specific type) and returns
a Boolean value, and the second set could be programs that take
one input value (of the same type as the programs in the first set).
Or whatever best serves your purposes.
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>> you are talking about. As you don't, your words don't mean anything. >>>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there >>>> is no universal set.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps of D
and involve zero to ∞ recursive simulations of H simulating itself
simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
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 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 simulated by any H ever reaches
its own line 06 and halts. This means that the input to H(D,D) is
ALWAYS non-halting.
Olcott again makes claims that he does not prove. What he shows here
only demonstrates that none of these H is able to do a correct
simulation and that none of them returns a correct answer, because none
of them simulates far enough to detect the halting behaviour. Not
surprising, because we know that for each H we can construct a D for
which it will return an incorrect result.
It seems he does not understand that, no matter how many steps are
simulated, it is always a few steps less then needed to detect the
halting behaviour.
On 5/7/2024 11:31 AM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>> you are talking about. As you don't, your words don't mean anything. >>>>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there >>>>> is no universal set.
This template defines an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
These H/D pairs can be enumerated by the one to ∞ simulated steps of
D and involve zero to ∞ recursive simulations of H simulating itself
simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
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 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 simulated by any H ever reaches
its own line 06 and halts. This means that the input to H(D,D) is
ALWAYS non-halting.
Olcott again makes claims that he does not prove.
No one can prove that 2 + 3 = 5 to anyone that does not know
how to count.
What he shows here only demonstrates that none of these H is able to
do a correct simulation and that none of them returns a correct
answer, because none of them simulates far enough to detect the
halting behaviour. Not
The only rebuttal to the above is the strawman deception of referring
to an H/D pair that is not an element of the set of D(D) simulated by H
that calls this same H(D,D).
int main() { D(D); }
is not an instance of D(D) simulated by H that calls this same H(D,D).
surprising, because we know that for each H we can construct a D for
which it will return an incorrect result.
It seems he does not understand that, no matter how many steps are
simulated, it is always a few steps less then needed to detect the
halting behaviour.
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>> you are talking about. As you don't, your words don't mean anything. >>>>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there >>>>> is no universal set.
This template defines an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
These H/D pairs can be enumerated by the one to ∞ simulated steps of
D and involve zero to ∞ recursive simulations of H simulating itself
simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of many
more simulations that only these.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
No-one can possibly show one element of this set where D(D) reaches
past its own line 03.
Like the pillow guys claims of evidence of election fraud people can
claim that there is evidence yet cannot possibly provide this evidence.
The pillow guy is losing ALL of his assets over his defamation.
In particular since the H as presented is not a pure function, but
uses hidden inputs. If hidden inputs are allowed, it is easy to
construct very different H functions, e.g., H functions for which the
number of steps differ at each simulation level.
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 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 simulated by any H ever reaches
its own line 06 and halts. This means that the input to H(D,D) is
ALWAYS non-halting.
It seems that olcott has found a subset of the infinite set of
possible H functions for which he can prove that none of them is able
to perform a good simulation, so they have to abort and guess an
answer, which happens to be wrong.
Not a surprising result, since for any H a D can be constructed for
which it will be unable to decide correctly.
On 5/7/2024 9:36 PM, Richard Damon wrote:
On 5/7/24 11:40 AM, olcott wrote:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>> you are talking about. As you don't, your words don't mean anything. >>>>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there >>>>> is no universal set.
This template defines an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
These H/D pairs can be enumerated by the one to ∞ simulated steps of
D and involve zero to ∞ recursive simulations of H simulating itself
simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Ok, and I can make an H that simulates its D to the final state.
Liar
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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. >>>>>
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.
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything.
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there
is no universal set.
No, it shows that he is just thinking of Nieve set theory, you know,
the one that was proven broken.
Usually the best way to introduce a set of pairs is that first two
sets are specified and then a rule that selects some pairs from
the Cartesian product of those two sets.
In the current case the first set could be the set programs that
take two input values (possibly of some specific type) and returns
a Boolean value, and the second set could be programs that take
one input value (of the same type as the programs in the first set).
Or whatever best serves your purposes.
On 5/7/24 12:31 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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. >>>>>>>>
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>> you are talking about. As you don't, your words don't mean anything. >>>>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there >>>>> is no universal set.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps of D >>> and involve zero to ∞ recursive simulations of H simulating itself
simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
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 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 simulated by any H ever reaches
its own line 06 and halts. This means that the input to H(D,D) is
ALWAYS non-halting.
Olcott again makes claims that he does not prove. What he shows here
only demonstrates that none of these H is able to do a correct
simulation and that none of them returns a correct answer, because none
of them simulates far enough to detect the halting behaviour. Not
surprising, because we know that for each H we can construct a D for
which it will return an incorrect result.
It seems he does not understand that, no matter how many steps are
simulated, it is always a few steps less then needed to detect the
halting behaviour.
Yep, he can only try to claim that H is correct by assuming that H is correct.
We also have the case that it is unclear if H is a program or an
infinte set of programs (in which case, how do we call it) and D isn't
a program either, but an infinite set of something.
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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. >>>>>>
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.
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything. >>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there
is no universal set.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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. >>>>>>>>
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>> you are talking about. As you don't, your words don't mean anything. >>>>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there >>>>> is no universal set.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps of D >>> and involve zero to ∞ recursive simulations of H simulating itself
simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of many
more simulations that only these.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
No-one can possibly show one element of this set where D(D) reaches
past its own line 03.
On 5/7/2024 3:40 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 21:05 schreef olcott:
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of >>>>>>>>> pairs
you are talking about. As you don't, your words don't mean
anything.
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D >>>>>>>> and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC >>>>>>> there
is no universal set.
This template defines an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same
H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps
of D and involve zero to ∞ recursive simulations of H simulating
itself simulating D(D). Every time Lines 1,2,3 are simulated again
defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of
many more simulations that only these.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
This template does not define any H. So,
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D).
it does not define a H/D pair
When by "define" you mean provide all of the source-code of H
you are right. That is not what I meant. I cannot provide
all of the source-code for an infinite set of functions.
either. The enumeration might be part of a definition for a set of H
functions, but the question was whether the enumeration defines the
whole set. If so, why is it limited to this enumeration?
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D).
This includes implementations of H that play tic-tac-toe.
It does not include any D not simulated by H.
It does not include and D(D) that does not call this H.
In particular since the H as presented is not a pure function,
but uses hidden inputs. If hidden inputs are allowed, it is easy
to construct very different H functions, e.g., H functions for
which the number of steps differ at each simulation level.
On 2024-05-08 02:39:06 +0000, Richard Damon said:
On 5/7/24 12:31 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>>> you are talking about. As you don't, your words don't mean
anything.
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC
there
is no universal set.
This template defines an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same
H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps of >>>> D and involve zero to ∞ recursive simulations of H simulating itself >>>> simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
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 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 simulated by any H ever reaches
its own line 06 and halts. This means that the input to H(D,D) is
ALWAYS non-halting.
Olcott again makes claims that he does not prove. What he shows here
only demonstrates that none of these H is able to do a correct
simulation and that none of them returns a correct answer, because
none of them simulates far enough to detect the halting behaviour.
Not surprising, because we know that for each H we can construct a D
for which it will return an incorrect result.
It seems he does not understand that, no matter how many steps are
simulated, it is always a few steps less then needed to detect the
halting behaviour.
Yep, he can only try to claim that H is correct by assuming that H is
correct.
We also have the case that it is unclear if H is a program or an
infinte set of programs (in which case, how do we call it) and D isn't
a program either, but an infinite set of something.
Often names of individuals are lower case letter and names of sets of individuals are upper case letters. If individuals are named with upper
case letters then sets can be named with script letters. If ASCII names
are preferred then $A, $B, ... can be used instead of script letters.
On 5/8/2024 3:59 AM, Mikko wrote:
On 2024-05-07 19:05:54 +0000, olcott said:
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>>>> you are talking about. As you don't, your words don't mean anything. >>>>>>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D >>>>>>>> and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there >>>>>>> is no universal set.
This template defines an infinite set of finite string H/D pairs where >>>>> each D(D) that is simulated by H(D,D) also calls this same H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps of D >>>>> and involve zero to ∞ recursive simulations of H simulating itself >>>>> simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of many
more simulations that only these.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
No-one can possibly show one element of this set where D(D) reaches
past its own line 03.
If H is a decider of any kind then the D build from it reaches its line
4 as numberd above. Whether the simulation of D by H reaches that line
is another question.
*My fully operational code proves otherwise*
I seems like you guys don't have a clue about how infinite
recursion works.
You can run the code and see that I am correct.
On 5/8/2024 3:59 AM, Mikko wrote:
On 2024-05-07 19:05:54 +0000, olcott said:
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>>>> you are talking about. As you don't, your words don't mean anything. >>>>>>>>>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D >>>>>>>> and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there >>>>>>> is no universal set.
This template defines an infinite set of finite string H/D pairs where each D(D) that is
simulated by H(D,D) also calls this same H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps of D and involve zero to ∞
recursive simulations of H simulating itself simulating D(D). Every time Lines 1,2,3 are
simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of many more simulations that only
these.
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
No-one can possibly show one element of this set where D(D) reaches
past its own line 03.
If H is a decider of any kind then the D build from it reaches its line
4 as numberd above. Whether the simulation of D by H reaches that line
is another question.
*My fully operational code proves otherwise*
I seems like you guys don't have a clue about how infinite
recursion works. You can run the code and see that I am correct.
I have one concrete instance as fully operational code. https://github.com/plolcott/x86utm/blob/master/Halt7.c
line 555 u32 HH(ptr P, ptr I) its input in on
line 932 int DD(int (*x)())
On 5/8/2024 4:07 AM, Fred. Zwarts wrote:
Op 07.mei.2024 om 23:23 schreef olcott:
On 5/7/2024 3:40 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 21:05 schreef olcott:
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of >>>>>>>>>>> pairs
you are talking about. As you don't, your words don't mean >>>>>>>>>>> anything.
Every H/D pair in the universe where D(D) is simulated by the >>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D >>>>>>>>>> and also includes zero to ∞ recursive simulations where H >>>>>>>>>> H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like >>>>>>>>> ZFC there
is no universal set.
This template defines an infinite set of finite string H/D pairs >>>>>>> where each D(D) that is simulated by H(D,D) also calls this same >>>>>>> H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps >>>>>>> of D and involve zero to ∞ recursive simulations of H simulating >>>>>>> itself simulating D(D). Every time Lines 1,2,3 are simulated
again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of
many more simulations that only these.
This template defines an infinite set of finite string H/D pairs where >>>>> each D(D) that is simulated by H(D,D) also calls this same H(D,D).
This template does not define any H. So,
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
it does not define a H/D pair
When by "define" you mean provide all of the source-code of H
you are right. That is not what I meant. I cannot provide
all of the source-code for an infinite set of functions.
either. The enumeration might be part of a definition for a set of H
functions, but the question was whether the enumeration defines the
whole set. If so, why is it limited to this enumeration?
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
This includes implementations of H that play tic-tac-toe.
It does not include any D not simulated by H.
It does not include and D(D) that does not call this H.
In particular since the H as presented is not a pure function,
but uses hidden inputs. If hidden inputs are allowed, it is easy
to construct very different H functions, e.g., H functions for
which the number of steps differ at each simulation level.
So, since olcott does not define H and he did not reject the idea of
*My fully operational code proves how it works*
I seems like you guys don't have a clue about how infinite
recursion works. You can run the code and see that I am correct.
I have one concrete instance as fully operational code. https://github.com/plolcott/x86utm/blob/master/Halt7.c
line 555 u32 HH(ptr P, ptr I) its input in on
line 932 int DD(int (*x)())
HH(DD,DD) determines that its input will never halt
by simulating itself simulating it and seeing that
this creates the exact same prior state of DD.
functions with hidden inputs, we can construct a H that keeps track
of > the simulation level. So, imagine a H that has as hidden input
not only
its own address, but also the address of an integer value, the
simulation level, initialised at 0. Each time H starts, it increments
the level and when it returns, it decrements the level. Then we can
construct a H that, when it sees that it is at level 1, it simulates
infinitely, but when it sees that it is at level 2, it aborts as soon
as it would start to simulate itself.
So, the inner simulated H aborts after one cycle and returns
non-halting, the simulated D then goes to line 04 and line 06 and
returns, and then the outer simulating H reports 'halting'.
So, we have a single H that reports different things about the same D.
Of course, also this outer simulating H is wrong, because when D is
called directly, it sees that the outer simulating H reports 'halting'
and therefore D does not halt.
So, this might be the solution to olcott's problem. Construct a H that
returns different results at each stimulation level, then at some
levels it is correct. It cannot be wrong when it gives both halting
and non-halting responses. :)
It has no further use, but everyone is happy. olcott is happy, because
this H gives a correct answer for its D in one of the simulation
levels and others are happy, because the halting theorem is not violated.
On 5/8/2024 4:07 AM, Fred. Zwarts wrote:
Op 07.mei.2024 om 23:23 schreef olcott:
On 5/7/2024 3:40 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 21:05 schreef olcott:
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of >>>>>>>>>>> pairs
you are talking about. As you don't, your words don't mean >>>>>>>>>>> anything.
Every H/D pair in the universe where D(D) is simulated by the >>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D >>>>>>>>>> and also includes zero to ∞ recursive simulations where H >>>>>>>>>> H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like >>>>>>>>> ZFC there
is no universal set.
This template defines an infinite set of finite string H/D pairs >>>>>>> where each D(D) that is simulated by H(D,D) also calls this same >>>>>>> H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps >>>>>>> of D and involve zero to ∞ recursive simulations of H simulating >>>>>>> itself simulating D(D). Every time Lines 1,2,3 are simulated
again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of
many more simulations that only these.
This template defines an infinite set of finite string H/D pairs where >>>>> each D(D) that is simulated by H(D,D) also calls this same H(D,D).
This template does not define any H. So,
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
it does not define a H/D pair
When by "define" you mean provide all of the source-code of H
you are right. That is not what I meant. I cannot provide
all of the source-code for an infinite set of functions.
either. The enumeration might be part of a definition for a set of H
functions, but the question was whether the enumeration defines the
whole set. If so, why is it limited to this enumeration?
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
This includes implementations of H that play tic-tac-toe.
It does not include any D not simulated by H.
It does not include and D(D) that does not call this H.
In particular since the H as presented is not a pure function,
but uses hidden inputs. If hidden inputs are allowed, it is easy
to construct very different H functions, e.g., H functions for
which the number of steps differ at each simulation level.
So, since olcott does not define H and he did not reject the idea of
*My fully operational code proves how it works*
I seems like you guys don't have a clue about how infinite
recursion works. You can run the code and see that I am correct.
I have one concrete instance as fully operational code. https://github.com/plolcott/x86utm/blob/master/Halt7.c
line 555 u32 HH(ptr P, ptr I) its input in on
line 932 int DD(int (*x)())
HH(DD,DD) determines that its input will never halt
by simulating itself simulating it and seeing that
this creates the exact same prior state of DD.
functions with hidden inputs, we can construct a H that keeps track
of > the simulation level. So, imagine a H that has as hidden input
not only
its own address, but also the address of an integer value, the
simulation level, initialised at 0. Each time H starts, it increments
the level and when it returns, it decrements the level. Then we can
construct a H that, when it sees that it is at level 1, it simulates
infinitely, but when it sees that it is at level 2, it aborts as soon
as it would start to simulate itself.
So, the inner simulated H aborts after one cycle and returns
non-halting, the simulated D then goes to line 04 and line 06 and
returns, and then the outer simulating H reports 'halting'.
So, we have a single H that reports different things about the same D.
Of course, also this outer simulating H is wrong, because when D is
called directly, it sees that the outer simulating H reports 'halting'
and therefore D does not halt.
So, this might be the solution to olcott's problem. Construct a H that
returns different results at each stimulation level, then at some
levels it is correct. It cannot be wrong when it gives both halting
and non-halting responses. :)
It has no further use, but everyone is happy. olcott is happy, because
this H gives a correct answer for its D in one of the simulation
levels and others are happy, because the halting theorem is not violated.
On 5/8/2024 4:07 AM, Fred. Zwarts wrote:
Op 07.mei.2024 om 23:23 schreef olcott:
On 5/7/2024 3:40 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 21:05 schreef olcott:
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of >>>>>>>>>>> pairs
you are talking about. As you don't, your words don't mean >>>>>>>>>>> anything.
Every H/D pair in the universe where D(D) is simulated by the >>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D >>>>>>>>>> and also includes zero to ∞ recursive simulations where H >>>>>>>>>> H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like >>>>>>>>> ZFC there
is no universal set.
This template defines an infinite set of finite string H/D pairs >>>>>>> where each D(D) that is simulated by H(D,D) also calls this same >>>>>>> H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated steps >>>>>>> of D and involve zero to ∞ recursive simulations of H simulating >>>>>>> itself simulating D(D). Every time Lines 1,2,3 are simulated
again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of
many more simulations that only these.
This template defines an infinite set of finite string H/D pairs where >>>>> each D(D) that is simulated by H(D,D) also calls this same H(D,D).
This template does not define any H. So,
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
it does not define a H/D pair
When by "define" you mean provide all of the source-code of H
you are right. That is not what I meant. I cannot provide
all of the source-code for an infinite set of functions.
either. The enumeration might be part of a definition for a set of H
functions, but the question was whether the enumeration defines the
whole set. If so, why is it limited to this enumeration?
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>
This includes implementations of H that play tic-tac-toe.
It does not include any D not simulated by H.
It does not include and D(D) that does not call this H.
In particular since the H as presented is not a pure function,
but uses hidden inputs. If hidden inputs are allowed, it is easy
to construct very different H functions, e.g., H functions for
which the number of steps differ at each simulation level.
So, since olcott does not define H and he did not reject the idea of
functions with hidden inputs,
I stopped reading right here.
Functions with hidden inputs are not allowed.
Since it is understood that we have only been talking about
computable functions there was no need to get more specific
than this.
Mike acknowledged that a machine can watch any of the changes
to any internal state of the machine it is simulating and these
are not hidden inputs. My simulating termination analyzer can
be built on this basis.
we can construct a H that keeps track of the simulation level. So,
imagine a H that has as hidden input not only its own address, but
also the address of an integer value, the simulation level,
initialised at 0. Each time H starts, it increments the level and when
it returns, it decrements the level. Then we can construct a H that,
when it sees that it is at level 1, it simulates infinitely, but when
it sees that it is at level 2, it aborts as soon as it would start to
simulate itself.
So, the inner simulated H aborts after one cycle and returns
non-halting, the simulated D then goes to line 04 and line 06 and
returns, and then the outer simulating H reports 'halting'.
So, we have a single H that reports different things about the same D.
Of course, also this outer simulating H is wrong, because when D is
called directly, it sees that the outer simulating H reports 'halting'
and therefore D does not halt.
So, this might be the solution to olcott's problem. Construct a H that
returns different results at each stimulation level, then at some
levels it is correct. It cannot be wrong when it gives both halting
and non-halting responses. :)
It has no further use, but everyone is happy. olcott is happy, because
this H gives a correct answer for its D in one of the simulation
levels and others are happy, because the halting theorem is not violated.
On 5/8/2024 11:07 AM, Mikko wrote:
On 2024-05-08 13:01:54 +0000, olcott said:
On 5/8/2024 3:59 AM, Mikko wrote:
On 2024-05-07 19:05:54 +0000, olcott said:
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set of pairs >>>>>>>>>>> you are talking about. As you don't, your words don't mean anything.
Every H/D pair in the universe where D(D) is simulated by the >>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D >>>>>>>>>> and also includes zero to ∞ recursive simulations where H >>>>>>>>>> H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like ZFC there
is no universal set.
This template defines an infinite set of finite string H/D pairs where >>>>>>> each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>>>>>
These H/D pairs can be enumerated by the one to ∞ simulated steps of D
and involve zero to ∞ recursive simulations of H simulating itself >>>>>>> simulating D(D). Every time Lines 1,2,3 are simulated again defines >>>>>>> one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of many >>>>>> more simulations that only these.
This template defines an infinite set of finite string H/D pairs where >>>>> each D(D) that is simulated by H(D,D) also calls this same H(D,D).
No-one can possibly show one element of this set where D(D) reaches
past its own line 03.
If H is a decider of any kind then the D build from it reaches its line >>>> 4 as numberd above. Whether the simulation of D by H reaches that line >>>> is another question.
*My fully operational code proves otherwise*
No, it doesn't.
I seems like you guys don't have a clue about how infinite
recursion works.
Sure we know. It works so that the program that does it never
returns and therefore is not any deider, and the calling
program doesn't return, either, so it isn't a decider, either.
*In other words you agree with this*
*In other words you agree with this*
*In other words you agree with this*
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 }
Any H/D pair matching the above template where D(D) is simulated
by the same H(D,D) that it calls cannot possibly reach past
it own line 03. Simple software engineering verified fact.
Op 08.mei.2024 om 21:23 schreef olcott:
On 5/8/2024 4:07 AM, Fred. Zwarts wrote:
Op 07.mei.2024 om 23:23 schreef olcott:
On 5/7/2024 3:40 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 21:05 schreef olcott:
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
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.
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.
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.
When you say "every H/D pair" you should specify which set >>>>>>>>>>>> of pairs
you are talking about. As you don't, your words don't mean >>>>>>>>>>>> anything.
Every H/D pair in the universe where D(D) is simulated by the >>>>>>>>>>> same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D >>>>>>>>>>> and also includes zero to ∞ recursive simulations where H >>>>>>>>>>> H simulates itself simulating D(D).
"In the universe" is not a set. In typical set theories like >>>>>>>>>> ZFC there
is no universal set.
This template defines an infinite set of finite string H/D pairs >>>>>>>> where each D(D) that is simulated by H(D,D) also calls this same >>>>>>>> H(D,D).
These H/D pairs can be enumerated by the one to ∞ simulated
steps of D and involve zero to ∞ recursive simulations of H
simulating itself simulating D(D). Every time Lines 1,2,3 are
simulated again defines
one more level of recursive simulation.
1st element of H/D pairs 1 step of D is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
Is this the definition of the infinite set of H? We can think of >>>>>>> many more simulations that only these.
This template defines an infinite set of finite string H/D pairs
where
each D(D) that is simulated by H(D,D) also calls this same H(D,D). >>>>>>
This template does not define any H. So,
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same
H(D,D).
it does not define a H/D pair
When by "define" you mean provide all of the source-code of H
you are right. That is not what I meant. I cannot provide
all of the source-code for an infinite set of functions.
either. The enumeration might be part of a definition for a set of
H functions, but the question was whether the enumeration defines
the whole set. If so, why is it limited to this enumeration?
The template specifies an infinite set of finite string H/D pairs
where each D(D) that is simulated by H(D,D) also calls this same
H(D,D).
This includes implementations of H that play tic-tac-toe.
It does not include any D not simulated by H.
It does not include and D(D) that does not call this H.
In particular since the H as presented is not a pure function,
but uses hidden inputs. If hidden inputs are allowed, it is easy >>>>>>> to construct very different H functions, e.g., H functions for
which the number of steps differ at each simulation level.
So, since olcott does not define H and he did not reject the idea of
functions with hidden inputs,
I stopped reading right here.
Functions with hidden inputs are not allowed.
Since it is understood that we have only been talking about
computable functions there was no need to get more specific
than this.
Mike acknowledged that a machine can watch any of the changes
to any internal state of the machine it is simulating and these
are not hidden inputs. My simulating termination analyzer can
be built on this basis.
Olcott refuses to define H. Each time someone comes with an example that refutes his claim he adds a new restriction to eliminate the example.
His infinite set of H is shrinking, so his 'proof' becomes less
interesting each time.
Olcott admitted that his H uses the address of H to recognize that a recursive simulation starts. So, he himself, uses hidden inputs. So, if hidden inputs are not allowed, his own H is not allowed.
Does he now introduce a very vague claim that the external simulator
would recognizes in some other way that a recursive simulation would
start? But then the simulator would be able to find out its own address
by looking at the address of the call. If that is possible, the same
method can be used to find out the address of the simulation level
integer. Once the address of this integer has been found, it is still possible to keep track of the simulation level. So, the construction
(below) of a simulator that simulates infinitely at the outer level, and
only one cycle at inner levels is still possible. Which refutes olcott's claim that no simulator can reach line 04 and 06.
we can construct a H that keeps track of the simulation level. So,
imagine a H that has as hidden input not only its own address, but
also the address of an integer value, the simulation level,
initialised at 0. Each time H starts, it increments the level and
when it returns, it decrements the level. Then we can construct a H
that, when it sees that it is at level 1, it simulates infinitely,
but when it sees that it is at level 2, it aborts as soon as it would
start to simulate itself.
So, the inner simulated H aborts after one cycle and returns
non-halting, the simulated D then goes to line 04 and line 06 and
returns, and then the outer simulating H reports 'halting'.
So, we have a single H that reports different things about the same D.
Of course, also this outer simulating H is wrong, because when D is
called directly, it sees that the outer simulating H reports
'halting' and therefore D does not halt.
So, this might be the solution to olcott's problem. Construct a H
that returns different results at each stimulation level, then at
some levels it is correct. It cannot be wrong when it gives both
halting and non-halting responses. :)
It has no further use, but everyone is happy. olcott is happy,
because this H gives a correct answer for its D in one of the
simulation levels and others are happy, because the halting theorem
is not violated.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 307 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 103:33:52 |
| Calls: | 6,851 |
| Calls today: | 2 |
| Files: | 12,355 |
| Messages: | 5,415,552 |