On 2025-11-05, olcott <[email protected]> wrote:
The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.
Yes; this doesn't happen while H is running.
So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.
D simulated by H cannot possibly reach its own
simulated final halt state.
I am not going to talk about any non-nonsense of
resuming a simulation after we already have this
final answer.
We just proved that the input to H(D)
specifies non-halting.
D simulated by H cannot possibly reach its own
simulated final halt state.
I am not going to talk about any non-nonsense of
resuming a simulation after we already have this
final answer.
We just proved that the input to H(D) specifies
non-halting. Anything beyond this is flogging a
dead horse.
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
Only a correct, complete simulation of D coincides
with D's behavior.
I am not going to talk about any non-nonsense of
resuming a simulation after we already have this
final answer.
And you think that statements like this will not be an obstacle when you present your work to cs/math academia?
Do you think that CS academics will buy the idea that a simulating
halt decider can leave a simulation object with unfinished steps,
such that those do not matter, and pronounce that simulation to be
never ending?
They are going to ask the obvious question: what if you take that
simulation and peform more steps, surely it halts, so the result was
wrong.
You need a /rational/ argument to explain why that is forbidden;
you cannot just /decree/ that it is so.
That's not how things work in the intellectual arts.
We just proved that the input to H(D) specifies
non-halting. Anything beyond this is flogging a
dead horse.
English language figures of speech are not a substitute
for logical reasoning.
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not)I have know that for many years.
D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's behavior.We don't give a rat's ass about the behavior of D. The input to H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a simulating haltAbsolutely.
decider can leave a simulation object with unfinished steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation to beAs soon as a non-terminating behavior pattern is correctly matched we
never ending?
are done.
It’s not the same. D halts when executed.They are going to ask the obvious question: what if you take thatThat we be the same as asking are we sure that Infinite_Loop() never terminates?
simulation and peform more steps, surely it halts, so the result was
wrong.
You haven’t even understood we are not resuming the simulatOR H.That's not how things work in the intellectual arts.You are simply totally wrong on this point about resuming a simulation.
Neither does you proclaiming somebody doesn’t get it entail that youEnglish language figures of speech are not a substitute for logicalThat you just don't get it does not entail that I am incorrect.
reasoning.
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
I have know that for many years. Is this new to you?
That we be the same as asking are we sure that
Infinite_Loop() never terminates? Do we need to
look at this again?
You need a /rational/ argument to explain why that is forbidden;
you cannot just /decree/ that it is so.
No rational argument needed simply look at
the execution trace.
That's not how things work in the intellectual arts.
You are simply totally wrong on this point about
resuming a simulation.
We just proved that the input to H(D) specifies
non-halting. Anything beyond this is flogging a
dead horse.
English language figures of speech are not a substitute
for logical reasoning.
That you just don't get it does not entail
that I am incorrect.
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
That goes directly against your claims.A partial simulation of D does not show whether (or not)I have know that for many years.
D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's behavior.We don't give a rat's ass about the behavior of D. The input to H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a simulating haltAbsolutely.
decider can leave a simulation object with unfinished steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation to beAs soon as a non-terminating behavior pattern is correctly matched we
never ending?
are done.
They are going to ask the obvious question: what if you take thatThat we be the same as asking are we sure that Infinite_Loop() never
simulation and peform more steps, surely it halts, so the result was
wrong.
terminates?
It’s not the same. D halts when executed.
You haven’t even understood we are not resuming the simulatOR H.That's not how things work in the intellectual arts.You are simply totally wrong on this point about resuming a simulation.
Neither does you proclaiming somebody doesn’t get it entail that youEnglish language figures of speech are not a substitute for logicalThat you just don't get it does not entail that I am incorrect.
reasoning.
are correct.
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
Only a correct, complete simulation of D coincides
with D's behavior.
I am not going to talk about any non-nonsense of
resuming a simulation after we already have this
final answer.
And you think that statements like this will not be an obstacle when you present your work to cs/math academia?
Do you think that CS academics will buy the idea that a simulating
halt decider can leave a simulation object with unfinished steps,
such that those do not matter, and pronounce that simulation to be
never ending?
They are going to ask the obvious question: what if you take that
simulation and peform more steps, surely it halts, so the result was
wrong.
You need a /rational/ argument to explain why that is forbidden;
you cannot just /decree/ that it is so.
That's not how things work in the intellectual arts.
We just proved that the input to H(D) specifies
non-halting. Anything beyond this is flogging a
dead horse.
English language figures of speech are not a substitute
for logical reasoning.
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not)I have know that for many years.
D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's behavior.We don't give a rat's ass about the behavior of D. The input to H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a simulating halt >>>> decider can leave a simulation object with unfinished steps,Absolutely.
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation to beAs soon as a non-terminating behavior pattern is correctly matched we
never ending?
are done.
They are going to ask the obvious question: what if you take thatThat we be the same as asking are we sure that Infinite_Loop() never
simulation and peform more steps, surely it halts, so the result was
wrong.
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not)I have know that for many years.
D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's behavior. >>>> We don't give a rat's ass about the behavior of D. The input to H(D)only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a simulatingAbsolutely.
halt
decider can leave a simulation object with unfinished steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation to beAs soon as a non-terminating behavior pattern is correctly matched we
never ending?
are done.
They are going to ask the obvious question: what if you take thatThat we be the same as asking are we sure that Infinite_Loop() never
simulation and peform more steps, surely it halts, so the result was >>>>> wrong.
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which is the description of machine D and therefore is stipulated to specify all
semantic properties of machine D including that it halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to H(D)
actually specifies are those of the directly executed machine D.
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not)I have know that for many years.
D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's behavior. >>>>> We don't give a rat's ass about the behavior of D. The input to H(D) >>>>> only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a simulating >>>>>> haltAbsolutely.
decider can leave a simulation object with unfinished steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation to be >>>>>> never ending?As soon as a non-terminating behavior pattern is correctly matched we >>>>> are done.
They are going to ask the obvious question: what if you take thatThat we be the same as asking are we sure that Infinite_Loop() never >>>>> terminates?
simulation and peform more steps, surely it halts, so the result was >>>>>> wrong.
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which is the
description of machine D and therefore is stipulated to specify all
semantic properties of machine D including that it halts when executed
directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to H(D)
actually specifies are those of the directly executed machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
has nothing to do
with the halting problem.
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not)I have know that for many years.
D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with D'sWe don't give a rat's ass about the behavior of D. The input to H(D) >>>>>> only specifies the behavior of D simulated by H.
behavior.
You are beyond the pail.Do you think that CS academics will buy the idea that aAbsolutely.
simulating halt
decider can leave a simulation object with unfinished steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation to be >>>>>>> never ending?As soon as a non-terminating behavior pattern is correctly matched we >>>>>> are done.
They are going to ask the obvious question: what if you take that >>>>>>> simulation and peform more steps, surely it halts, so the result was >>>>>>> wrong.That we be the same as asking are we sure that Infinite_Loop() never >>>>>> terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which is the
description of machine D and therefore is stipulated to specify all
semantic properties of machine D including that it halts when
executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to H(D)
actually specifies are those of the directly executed machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of machine D, specifies all semantic properties of the directly executed D is a
semantic tautology.
Disagreeing with a semantic tautology is always incorrect.
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
If you don't address this specific point and
instead spew out dogma you will be *plonked*
has nothing to do with the halting problem.
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not)I have know that for many years.
D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with D'sWe don't give a rat's ass about the behavior of D. The input to H(D) >>>>>>> only specifies the behavior of D simulated by H.
behavior.
You are beyond the pail.Do you think that CS academics will buy the idea that aAbsolutely.
simulating halt
decider can leave a simulation object with unfinished steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation to be >>>>>>>> never ending?As soon as a non-terminating behavior pattern is correctly
matched we
are done.
They are going to ask the obvious question: what if you take that >>>>>>>> simulation and peform more steps, surely it halts, so the result >>>>>>>> wasThat we be the same as asking are we sure that Infinite_Loop() never >>>>>>> terminates?
wrong.
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which is the
description of machine D and therefore is stipulated to specify all
semantic properties of machine D including that it halts when
executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to H(D)
actually specifies are those of the directly executed machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of machine
D, specifies all semantic properties of the directly executed D is a
semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
Disagreeing with a semantic tautology is always incorrect.
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic numbers to be
both greater than 5 and less than 3, it is not incorrect to require a
halt decider to report whether any arbitrary Turing machine X with input
Y will halt when executed directly.
It just means that halt deciders, like Mythic numbers, don't exist.
If you don't address this specific point and
instead spew out dogma you will be *plonked*
has nothing to do with the halting problem.
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not)I have know that for many years.
D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's >>>>>>>>> behavior.We don't give a rat's ass about the behavior of D. The input to >>>>>>>> H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that aAbsolutely.
simulating halt
decider can leave a simulation object with unfinished steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation to be >>>>>>>>> never ending?As soon as a non-terminating behavior pattern is correctly
matched we
are done.
They are going to ask the obvious question: what if you take that >>>>>>>>> simulation and peform more steps, surely it halts, so theThat we be the same as asking are we sure that Infinite_Loop() >>>>>>>> never
result was
wrong.
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which is the >>>>> description of machine D and therefore is stipulated to specify all >>>>> semantic properties of machine D including that it halts when
executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to H(D)
actually specifies are those of the directly executed machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of machine
D, specifies all semantic properties of the directly executed D is a
semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
that the steps of the algorithm D that
algorithm H simulates are exactly the same as the steps of algorithm D
being executed directly.
It's just that algorithm H doesn't simulate all of those steps.
Disagreeing with a semantic tautology is always incorrect.
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not)I have know that for many years.
D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's >>>>>>>>>> behavior.We don't give a rat's ass about the behavior of D. The input to >>>>>>>>> H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a
simulating halt
decider can leave a simulation object with unfinished steps, >>>>>>>>> Absolutely.
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation >>>>>>>>>> to beAs soon as a non-terminating behavior pattern is correctly
never ending?
matched we
are done.
They are going to ask the obvious question: what if you take that >>>>>>>>>> simulation and peform more steps, surely it halts, so the >>>>>>>>>> result wasThat we be the same as asking are we sure that Infinite_Loop() >>>>>>>>> never
wrong.
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which is
the description of machine D and therefore is stipulated to
specify all semantic properties of machine D including that it
halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to H(D) >>>>>> actually specifies are those of the directly executed machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of
machine D, specifies all semantic properties of the directly
executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
that the steps of the algorithm D that algorithm H simulates are
exactly the same as the steps of algorithm D being executed directly.
It's just that algorithm H doesn't simulate all of those steps.
Disagreeing with a semantic tautology is always incorrect.
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic numbers to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
The halting problem DOES REQUIRE deciders to
to report on a different sequence of steps than
the sequence of steps that their
ACTUAL INPUTS ACTUALLY SPECIFY.
(Not plonked yet) you did slightly address the point.
both greater than 5 and less than 3, it is not incorrect to require a
halt decider to report whether any arbitrary Turing machine X with
input Y will halt when executed directly.
It just means that halt deciders, like Mythic numbers, don't exist.
If you don't address this specific point and
instead spew out dogma you will be *plonked*
has nothing to do with the halting problem.
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not) >>>>>>>>>>> D reaches a halt state.I have know that for many years.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's >>>>>>>>>>> behavior.We don't give a rat's ass about the behavior of D. The input >>>>>>>>>> to H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a >>>>>>>>>>> simulating halt
decider can leave a simulation object with unfinished steps, >>>>>>>>>> Absolutely.
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation >>>>>>>>>>> to beAs soon as a non-terminating behavior pattern is correctly >>>>>>>>>> matched we
never ending?
are done.
They are going to ask the obvious question: what if you take >>>>>>>>>>> thatThat we be the same as asking are we sure that Infinite_Loop() >>>>>>>>>> never
simulation and peform more steps, surely it halts, so the >>>>>>>>>>> result was
wrong.
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which is >>>>>>> the description of machine D and therefore is stipulated to
specify all semantic properties of machine D including that it
halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to H(D) >>>>>>> actually specifies are those of the directly executed machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of
machine D, specifies all semantic properties of the directly
executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
that the steps of the algorithm D that algorithm H simulates are
exactly the same as the steps of algorithm D being executed directly.
It's just that algorithm H doesn't simulate all of those steps.
Disagreeing with a semantic tautology is always incorrect.
On 11/6/2025 5:32 PM, dbush wrote:
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:If that was true then you could show the steps of D
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not) >>>>>>>>>>>> D reaches a halt state.I have know that for many years.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's >>>>>>>>>>>> behavior.We don't give a rat's ass about the behavior of D. The input >>>>>>>>>>> to H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a >>>>>>>>>>>> simulating halt
decider can leave a simulation object with unfinished steps, >>>>>>>>>>> Absolutely.
Now you only need to prove the correctness.such that those do not matter, and pronounce that simulation >>>>>>>>>>>> to beAs soon as a non-terminating behavior pattern is correctly >>>>>>>>>>> matched we
never ending?
are done.
They are going to ask the obvious question: what if you take >>>>>>>>>>>> thatThat we be the same as asking are we sure that
simulation and peform more steps, surely it halts, so the >>>>>>>>>>>> result was
wrong.
Infinite_Loop() never
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which is >>>>>>>> the description of machine D and therefore is stipulated to
specify all semantic properties of machine D including that it >>>>>>>> halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to H(D) >>>>>>>> actually specifies are those of the directly executed machine D. >>>>>>>
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of
machine D, specifies all semantic properties of the directly
executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
You are getting close to being plonked.
every TM has a machine description
that the steps of the algorithm D that algorithm H simulates are
exactly the same as the steps of algorithm D being executed directly.
It's just that algorithm H doesn't simulate all of those steps.
Disagreeing with a semantic tautology is always incorrect.
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic numbers to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in wording for
the last 3 years.
The halting problem DOES REQUIRE deciders to
to report on a different sequence of steps than
the sequence of steps that their
ACTUAL INPUTS ACTUALLY SPECIFY.
False, because the input to H(D), i.e. finite string D which is the description of machine D and therefore is stipulated to specify all
semantic properties of machine D including that it halts when executed directly.
Therefore, the steps that the actual input to H(D) actually specifies
are those of the directly executed machine D.
It's just that algorithm H doesn't correctly report on those steps.
(Not plonked yet) you did slightly address the point.
both greater than 5 and less than 3, it is not incorrect to require a
halt decider to report whether any arbitrary Turing machine X with
input Y will halt when executed directly.
It just means that halt deciders, like Mythic numbers, don't exist.
If you don't address this specific point and
instead spew out dogma you will be *plonked*
has nothing to do with the halting problem.
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:You cannot truthfully assess this as false
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic numbers to be >>>
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in wording
for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
I went through all of my steps of all of my
different halting problem proofs with Claude AI
and it understood all of them.
It did not quite accept all of my conclusions
but it did understand every step of several
different proofs. The sessions yesterday with
Claude AI made much more progress than all
of the human reviewers (from every forum) put
together over the last 22 years.
Humans begin with minds almost entirely closed.
The halting problem DOES REQUIRE deciders to
to report on a different sequence of steps than
the sequence of steps that their
ACTUAL INPUTS ACTUALLY SPECIFY.
False, because the input to H(D), i.e. finite string D which is the
description of machine D and therefore is stipulated to specify all
semantic properties of machine D including that it halts when executed
directly.
Therefore, the steps that the actual input to H(D) actually specifies
are those of the directly executed machine D.
It's just that algorithm H doesn't correctly report on those steps.
(Not plonked yet) you did slightly address the point.
both greater than 5 and less than 3, it is not incorrect to require
a halt decider to report whether any arbitrary Turing machine X with
input Y will halt when executed directly.
It just means that halt deciders, like Mythic numbers, don't exist.
If you don't address this specific point and
instead spew out dogma you will be *plonked*
has nothing to do with the halting problem.
On 11/6/2025 6:36 PM, olcott wrote:
On 11/6/2025 5:32 PM, dbush wrote:
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>> D reaches a halt state.I have know that for many years.
Nobody cares about H.Only a correct, complete simulation of D coincides with D's >>>>>>>>>>>>> behavior.We don't give a rat's ass about the behavior of D. The input >>>>>>>>>>>> to H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a >>>>>>>>>>>>> simulating halt
decider can leave a simulation object with unfinished steps, >>>>>>>>>>>> Absolutely.
Now you only need to prove the correctness.such that those do not matter, and pronounce thatAs soon as a non-terminating behavior pattern is correctly >>>>>>>>>>>> matched we
simulation to be
never ending?
are done.
They are going to ask the obvious question: what if you >>>>>>>>>>>>> take thatThat we be the same as asking are we sure that
simulation and peform more steps, surely it halts, so the >>>>>>>>>>>>> result was
wrong.
Infinite_Loop() never
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which is >>>>>>>>> the description of machine D and therefore is stipulated to >>>>>>>>> specify all semantic properties of machine D including that it >>>>>>>>> halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to >>>>>>>>> H(D) actually specifies are those of the directly executed
machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of
machine D, specifies all semantic properties of the directly
executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
You are getting close to being plonked.
It's not my fault you don't understand stipulative definitions. Here's one:
Turing machine description: a finite string that specifies all semantic properties of the machine being described.
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence
can refer to a C function, an algorithm, or a finite string, and the
meaning changes depending on which one is chosen.
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:You cannot truthfully assess this as false
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic numbers to be >>>>
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in wording
for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
as "D" and "H" in the above sentence
can refer to a C function, an algorithm, or a finite string, and the
meaning changes depending on which one is chosen.
Add exactly one of the following qualifiers to all instances of "D" and
"H" in the above sentence:
* C function
* algorithm
* finite string
I went through all of my steps of all of my
different halting problem proofs with Claude AI
and it understood all of them.
It did not quite accept all of my conclusions
but it did understand every step of several
different proofs. The sessions yesterday with
Claude AI made much more progress than all
of the human reviewers (from every forum) put
together over the last 22 years.
Humans begin with minds almost entirely closed.
The halting problem DOES REQUIRE deciders to
to report on a different sequence of steps than
the sequence of steps that their
ACTUAL INPUTS ACTUALLY SPECIFY.
False, because the input to H(D), i.e. finite string D which is the
description of machine D and therefore is stipulated to specify all
semantic properties of machine D including that it halts when
executed directly.
Therefore, the steps that the actual input to H(D) actually specifies
are those of the directly executed machine D.
It's just that algorithm H doesn't correctly report on those steps.
(Not plonked yet) you did slightly address the point.
both greater than 5 and less than 3, it is not incorrect to require >>>>> a halt decider to report whether any arbitrary Turing machine X
with input Y will halt when executed directly.
It just means that halt deciders, like Mythic numbers, don't exist.
If you don't address this specific point and
instead spew out dogma you will be *plonked*
has nothing to do with the halting problem.
On 11/6/2025 5:43 PM, dbush wrote:
On 11/6/2025 6:36 PM, olcott wrote:
On 11/6/2025 5:32 PM, dbush wrote:
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote:
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>> D reaches a halt state.I have know that for many years.
Nobody cares about H.Only a correct, complete simulation of D coincides with >>>>>>>>>>>>>> D's behavior.We don't give a rat's ass about the behavior of D. The >>>>>>>>>>>>> input to H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a >>>>>>>>>>>>>> simulating halt
decider can leave a simulation object with unfinished steps, >>>>>>>>>>>>> Absolutely.
Now you only need to prove the correctness.such that those do not matter, and pronounce that >>>>>>>>>>>>>> simulation to beAs soon as a non-terminating behavior pattern is correctly >>>>>>>>>>>>> matched we
never ending?
are done.
They are going to ask the obvious question: what if you >>>>>>>>>>>>>> take thatThat we be the same as asking are we sure that
simulation and peform more steps, surely it halts, so the >>>>>>>>>>>>>> result was
wrong.
Infinite_Loop() never
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which >>>>>>>>>> is the description of machine D and therefore is stipulated to >>>>>>>>>> specify all semantic properties of machine D including that it >>>>>>>>>> halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to >>>>>>>>>> H(D) actually specifies are those of the directly executed >>>>>>>>>> machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of >>>>>>>> machine D, specifies all semantic properties of the directly
executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
You are getting close to being plonked.
It's not my fault you don't understand stipulative definitions.
Here's one:
Turing machine description: a finite string that specifies all
semantic properties of the machine being described.
Good you are being responsive. We can build an honest
dialogue on this basis.
On 11/6/2025 5:52 PM, dbush wrote:
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:You cannot truthfully assess this as false
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic numbers to be >>>>>
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in wording
for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
Only if you are clueless about the semantics
of the C programming language.
as "D" and "H" in the above sentence can refer to a C function, an
algorithm, or a finite string, and the meaning changes depending on
which one is chosen.
We have been through this too many times.
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence
can refer to a C function, an algorithm, or a finite string, and the
meaning changes depending on which one is chosen.
Not only to that. "D" can refer to "simulation of D" which subdivides
into "partial simulation of D" and "complete simulation of D".
The D which is a "simulation of D" has no return statement; it is
the C function D which has that statement.
So D simulated by H (D, the partial simulation of D) not reaching
its return statement really means that something which doesn't /have/ a return statement is of course not reaching what it does not have.
On 11/6/2025 6:59 PM, olcott wrote:
On 11/6/2025 5:43 PM, dbush wrote:
On 11/6/2025 6:36 PM, olcott wrote:
On 11/6/2025 5:32 PM, dbush wrote:
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:That goes directly against your claims.
On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>I have know that for many years.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>>> D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with >>>>>>>>>>>>>>> D's behavior.We don't give a rat's ass about the behavior of D. The >>>>>>>>>>>>>> input to H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a >>>>>>>>>>>>>>> simulating halt
decider can leave a simulation object with unfinished steps, >>>>>>>>>>>>>> Absolutely.
Now you only need to prove the correctness.such that those do not matter, and pronounce that >>>>>>>>>>>>>>> simulation to beAs soon as a non-terminating behavior pattern is correctly >>>>>>>>>>>>>> matched we
never ending?
are done.
They are going to ask the obvious question: what if you >>>>>>>>>>>>>>> take thatThat we be the same as asking are we sure that
simulation and peform more steps, surely it halts, so the >>>>>>>>>>>>>>> result was
wrong.
Infinite_Loop() never
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which >>>>>>>>>>> is the description of machine D and therefore is stipulated >>>>>>>>>>> to specify all semantic properties of machine D including >>>>>>>>>>> that it halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to >>>>>>>>>>> H(D) actually specifies are those of the directly executed >>>>>>>>>>> machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement
nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of >>>>>>>>> machine D, specifies all semantic properties of the directly >>>>>>>>> executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
You are getting close to being plonked.
It's not my fault you don't understand stipulative definitions.
Here's one:
Turing machine description: a finite string that specifies all
semantic properties of the machine being described.
Good you are being responsive. We can build an honest
dialogue on this basis.
Then you agree that
the input to H(D), i.e. the description of Turing--
machine D, possesses the semantic property of halting.
On 11/6/2025 7:01 PM, olcott wrote:
On 11/6/2025 5:52 PM, dbush wrote:
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not) >>>>>>>>>>> D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic numbers >>>>>>> to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in
wording for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
Only if you are clueless about the semantics
of the C programming language.
The posted code contains function D, algorithm D, and finite string D,
and similarly for "H". So the above sentence could be referring to any
of those.
as "D" and "H" in the above sentence can refer to a C function, an
algorithm, or a finite string, and the meaning changes depending on
which one is chosen.
We have been through this too many times.
And every time, you have proved that you are not interested in an honest dialogue by refusing to add exactly one of the following qualifiers to
all instances of "D" and "H" in the above sentence:
* C function
* algorithm
* finite string
On 11/6/2025 6:05 PM, dbush wrote:
On 11/6/2025 7:01 PM, olcott wrote:
On 11/6/2025 5:52 PM, dbush wrote:
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>> D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic numbers >>>>>>>> to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in
wording for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
Only if you are clueless about the semantics
of the C programming language.
The posted code contains function D, algorithm D, and finite string D,
and similarly for "H". So the above sentence could be referring to
any of those.
DO YOU HAVE A MENTAL DISABILITY
THAT CAUSES YOU TO IMMEDIATELY FORGET
WHAT WAS JUST EXPLAINED TO YOU?
I am not going to endlessly repeat all
of the details if you are just being a jackass.
as "D" and "H" in the above sentence can refer to a C function, an
algorithm, or a finite string, and the meaning changes depending on
which one is chosen.
We have been through this too many times.
And every time, you have proved that you are not interested in an
honest dialogue by refusing to add exactly one of the following
qualifiers to all instances of "D" and "H" in the above sentence:
* C function
* algorithm
* finite string
On 11/6/2025 6:02 PM, dbush wrote:
On 11/6/2025 6:59 PM, olcott wrote:
On 11/6/2025 5:43 PM, dbush wrote:
On 11/6/2025 6:36 PM, olcott wrote:
On 11/6/2025 5:32 PM, dbush wrote:
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
That goes directly against your claims.On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>I have know that for many years.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>>>> D reaches a halt state.
Nobody cares about H.Only a correct, complete simulation of D coincides with >>>>>>>>>>>>>>>> D's behavior.We don't give a rat's ass about the behavior of D. The >>>>>>>>>>>>>>> input to H(D)
only specifies the behavior of D simulated by H.
You are beyond the pail.Do you think that CS academics will buy the idea that a >>>>>>>>>>>>>>>> simulating haltAbsolutely.
decider can leave a simulation object with unfinished >>>>>>>>>>>>>>>> steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that >>>>>>>>>>>>>>>> simulation to beAs soon as a non-terminating behavior pattern is >>>>>>>>>>>>>>> correctly matched we
never ending?
are done.
They are going to ask the obvious question: what if you >>>>>>>>>>>>>>>> take thatThat we be the same as asking are we sure that
simulation and peform more steps, surely it halts, so >>>>>>>>>>>>>>>> the result was
wrong.
Infinite_Loop() never
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D which >>>>>>>>>>>> is the description of machine D and therefore is stipulated >>>>>>>>>>>> to specify all semantic properties of machine D including >>>>>>>>>>>> that it halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input
actually specifies.
False. As proven above, the steps that the actual input to >>>>>>>>>>>> H(D) actually specifies are those of the directly executed >>>>>>>>>>>> machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement >>>>>>>>>>> nitwit. None of the moronic stopping and starting over
bullshit.
That the input to H(D), i.e. the finite string description of >>>>>>>>>> machine D, specifies all semantic properties of the directly >>>>>>>>>> executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
You are getting close to being plonked.
It's not my fault you don't understand stipulative definitions.
Here's one:
Turing machine description: a finite string that specifies all
semantic properties of the machine being described.
Good you are being responsive. We can build an honest
dialogue on this basis.
Then you agree that
No you have to go back and read the rest of what I said.
It is incorrect to disagree with stipulative definitions. https://en.wikipedia.org/wiki/Stipulative_definition
Disagreeing with a stipulative definition is like disagreeing with arithmetic.
the input to H(D), i.e. the description of Turing machine D, possesses
the semantic property of halting.
On 11/6/2025 7:30 PM, olcott wrote:
On 11/6/2025 6:05 PM, dbush wrote:
On 11/6/2025 7:01 PM, olcott wrote:
On 11/6/2025 5:52 PM, dbush wrote:
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>> D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>> D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic numbers >>>>>>>>> to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in
wording for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
Only if you are clueless about the semantics
of the C programming language.
The posted code contains function D, algorithm D, and finite string
D, and similarly for "H". So the above sentence could be referring
to any of those.
DO YOU HAVE A MENTAL DISABILITY
THAT CAUSES YOU TO IMMEDIATELY FORGET
WHAT WAS JUST EXPLAINED TO YOU?
I am not going to endlessly repeat all
of the details if you are just being a jackass.
All you have to do to prove you're interested in an honest dialogue is
to fix the above sentence
by qualifying each instance of "D" and "H" in
the above sentence with exactly one of:
* C function
* algorithm
* finite string
Only liars refuse to clarify their statements.
as "D" and "H" in the above sentence can refer to a C function, an
algorithm, or a finite string, and the meaning changes depending on >>>>> which one is chosen.
We have been through this too many times.
And every time, you have proved that you are not interested in an
honest dialogue by refusing to add exactly one of the following
qualifiers to all instances of "D" and "H" in the above sentence:
* C function
* algorithm
* finite string
On 11/6/2025 7:28 PM, olcott wrote:
On 11/6/2025 6:02 PM, dbush wrote:
On 11/6/2025 6:59 PM, olcott wrote:
On 11/6/2025 5:43 PM, dbush wrote:
On 11/6/2025 6:36 PM, olcott wrote:
On 11/6/2025 5:32 PM, dbush wrote:
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
That goes directly against your claims.On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>>I have know that for many years.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>>>>> D reaches a halt state.
You are beyond the pail.Only a correct, complete simulation of D coincides with >>>>>>>>>>>>>>>>> D's behavior.We don't give a rat's ass about the behavior of D. The >>>>>>>>>>>>>>>> input to H(D)
only specifies the behavior of D simulated by H. >>>>>>>>>>>>>>> Nobody cares about H.
Do you think that CS academics will buy the idea that a >>>>>>>>>>>>>>>>> simulating haltAbsolutely.
decider can leave a simulation object with unfinished >>>>>>>>>>>>>>>>> steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that >>>>>>>>>>>>>>>>> simulation to beAs soon as a non-terminating behavior pattern is >>>>>>>>>>>>>>>> correctly matched we
never ending?
are done.
They are going to ask the obvious question: what if you >>>>>>>>>>>>>>>>> take thatThat we be the same as asking are we sure that >>>>>>>>>>>>>>>> Infinite_Loop() never
simulation and peform more steps, surely it halts, so >>>>>>>>>>>>>>>>> the result was
wrong.
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D >>>>>>>>>>>>> which is the description of machine D and therefore is >>>>>>>>>>>>> stipulated to specify all semantic properties of machine D >>>>>>>>>>>>> including that it halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input >>>>>>>>>>>>>> actually specifies.
False. As proven above, the steps that the actual input to >>>>>>>>>>>>> H(D) actually specifies are those of the directly executed >>>>>>>>>>>>> machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement >>>>>>>>>>>> nitwit. None of the moronic stopping and starting over >>>>>>>>>>>> bullshit.
That the input to H(D), i.e. the finite string description of >>>>>>>>>>> machine D, specifies all semantic properties of the directly >>>>>>>>>>> executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
You are getting close to being plonked.
It's not my fault you don't understand stipulative definitions.
Here's one:
Turing machine description: a finite string that specifies all
semantic properties of the machine being described.
Good you are being responsive. We can build an honest
dialogue on this basis.
Then you agree that
No you have to go back and read the rest of what I said.
On 4/2/22 6:43 PM, olcott wrote:
It is incorrect to disagree with stipulative definitions. https://en.wikipedia.org/wiki/Stipulative_definition
Disagreeing with a stipulative definition is like disagreeing with arithmetic.
the input to H(D), i.e. the description of Turing machine D,
possesses the semantic property of halting.
On 11/6/2025 6:36 PM, dbush wrote:
On 11/6/2025 7:30 PM, olcott wrote:
On 11/6/2025 6:05 PM, dbush wrote:
On 11/6/2025 7:01 PM, olcott wrote:
On 11/6/2025 5:52 PM, dbush wrote:
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>> D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about
Is proving that the halting problem has always
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic
numbers to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in
wording for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
Only if you are clueless about the semantics
of the C programming language.
The posted code contains function D, algorithm D, and finite string
D, and similarly for "H". So the above sentence could be referring
to any of those.
DO YOU HAVE A MENTAL DISABILITY
THAT CAUSES YOU TO IMMEDIATELY FORGET
WHAT WAS JUST EXPLAINED TO YOU?
I am not going to endlessly repeat all
of the details if you are just being a jackass.
All you have to do to prove you're interested in an honest dialogue is
to fix the above sentence
by qualifying each instance of "D" and "H" in the above sentence with
exactly one of:
* C function
* algorithm
* finite string
Only liars refuse to clarify their statements.
I already fully addressed this twice.
Only jackasses or people with mental
disabilities ignore complete answers
and keep asking the same question.
as "D" and "H" in the above sentence can refer to a C function, an >>>>>> algorithm, or a finite string, and the meaning changes depending
on which one is chosen.
We have been through this too many times.
And every time, you have proved that you are not interested in an
honest dialogue by refusing to add exactly one of the following
qualifiers to all instances of "D" and "H" in the above sentence:
* C function
* algorithm
* finite string
On 11/6/2025 6:37 PM, dbush wrote:
On 11/6/2025 7:28 PM, olcott wrote:
On 11/6/2025 6:02 PM, dbush wrote:
On 11/6/2025 6:59 PM, olcott wrote:
On 11/6/2025 5:43 PM, dbush wrote:
On 11/6/2025 6:36 PM, olcott wrote:
On 11/6/2025 5:32 PM, dbush wrote:
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
That goes directly against your claims.On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>>>I have know that for many years.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>>>>>> D reaches a halt state.
You are beyond the pail.Only a correct, complete simulation of D coincides >>>>>>>>>>>>>>>>>> with D's behavior.We don't give a rat's ass about the behavior of D. The >>>>>>>>>>>>>>>>> input to H(D)
only specifies the behavior of D simulated by H. >>>>>>>>>>>>>>>> Nobody cares about H.
Do you think that CS academics will buy the idea that >>>>>>>>>>>>>>>>>> a simulating haltAbsolutely.
decider can leave a simulation object with unfinished >>>>>>>>>>>>>>>>>> steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that >>>>>>>>>>>>>>>>>> simulation to beAs soon as a non-terminating behavior pattern is >>>>>>>>>>>>>>>>> correctly matched we
never ending?
are done.
They are going to ask the obvious question: what if >>>>>>>>>>>>>>>>>> you take thatThat we be the same as asking are we sure that >>>>>>>>>>>>>>>>> Infinite_Loop() never
simulation and peform more steps, surely it halts, so >>>>>>>>>>>>>>>>>> the result was
wrong.
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D >>>>>>>>>>>>>> which is the description of machine D and therefore is >>>>>>>>>>>>>> stipulated to specify all semantic properties of machine D >>>>>>>>>>>>>> including that it halts when executed directly.
It requires H to have the psychic powers to see
steps that are not the steps that its actual input >>>>>>>>>>>>>>> actually specifies.
False. As proven above, the steps that the actual input >>>>>>>>>>>>>> to H(D) actually specifies are those of the directly >>>>>>>>>>>>>> executed machine D.
If that was true then you could show the steps of D
simulated by H reaching its simulated "return" statement >>>>>>>>>>>>> nitwit. None of the moronic stopping and starting over >>>>>>>>>>>>> bullshit.
That the input to H(D), i.e. the finite string description >>>>>>>>>>>> of machine D, specifies all semantic properties of the >>>>>>>>>>>> directly executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
You are getting close to being plonked.
It's not my fault you don't understand stipulative definitions.
Here's one:
Turing machine description: a finite string that specifies all
semantic properties of the machine being described.
Good you are being responsive. We can build an honest
dialogue on this basis.
Then you agree that
No you have to go back and read the rest of what I said.
On 4/2/22 6:43 PM, olcott wrote:
It is incorrect to disagree with stipulative definitions.
https://en.wikipedia.org/wiki/Stipulative_definition
;
Disagreeing with a stipulative definition is like disagreeing with
arithmetic.
*Unless a set of stipulative definitions disagrees with itself*
On 11/6/2025 7:44 PM, olcott wrote:
On 11/6/2025 6:36 PM, dbush wrote:
On 11/6/2025 7:30 PM, olcott wrote:
On 11/6/2025 6:05 PM, dbush wrote:
On 11/6/2025 7:01 PM, olcott wrote:
On 11/6/2025 5:52 PM, dbush wrote:
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:Is proving that the halting problem has always
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own >>>>>>>>>>>>>>>> simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>>> D reaches a halt state.
We are never taking about the directly executed D.
Then you are admitting that what you're talking about >>>>>>>>>>>>
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic >>>>>>>>>>> numbers to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in >>>>>>>>> wording for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
Only if you are clueless about the semantics
of the C programming language.
The posted code contains function D, algorithm D, and finite string >>>>> D, and similarly for "H". So the above sentence could be referring >>>>> to any of those.
DO YOU HAVE A MENTAL DISABILITY
THAT CAUSES YOU TO IMMEDIATELY FORGET
WHAT WAS JUST EXPLAINED TO YOU?
I am not going to endlessly repeat all
of the details if you are just being a jackass.
All you have to do to prove you're interested in an honest dialogue
is to fix the above sentence
by qualifying each instance of "D" and "H" in the above sentence with
exactly one of:
* C function
* algorithm
* finite string
Only liars refuse to clarify their statements.
I already fully addressed this twice.
Only jackasses or people with mental
disabilities ignore complete answers
and keep asking the same question.
There was no complete answer because
On 11/6/2025 6:49 PM, dbush wrote:
On 11/6/2025 7:44 PM, olcott wrote:
On 11/6/2025 6:36 PM, dbush wrote:
On 11/6/2025 7:30 PM, olcott wrote:
On 11/6/2025 6:05 PM, dbush wrote:
On 11/6/2025 7:01 PM, olcott wrote:
On 11/6/2025 5:52 PM, dbush wrote:
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:Is proving that the halting problem has always
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:Then you are admitting that what you're talking about >>>>>>>>>>>>>
On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own >>>>>>>>>>>>>>>>> simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>>>> D reaches a halt state.
We are never taking about the directly executed D. >>>>>>>>>>>>>>
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence
of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic >>>>>>>>>>>> numbers to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in >>>>>>>>>> wording for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
Only if you are clueless about the semantics
of the C programming language.
The posted code contains function D, algorithm D, and finite
string D, and similarly for "H". So the above sentence could be >>>>>> referring to any of those.
DO YOU HAVE A MENTAL DISABILITY
THAT CAUSES YOU TO IMMEDIATELY FORGET
WHAT WAS JUST EXPLAINED TO YOU?
I am not going to endlessly repeat all
of the details if you are just being a jackass.
All you have to do to prove you're interested in an honest dialogue
is to fix the above sentence
by qualifying each instance of "D" and "H" in the above sentence
with exactly one of:
* C function
* algorithm
* finite string
Only liars refuse to clarify their statements.
I already fully addressed this twice.
Only jackasses or people with mental
disabilities ignore complete answers
and keep asking the same question.
There was no complete answer because
I completely defined D twice and you did
not revise your question to account for this.
Are you a jackass or do you have mental
disabilities?
1) you referred to "H" as "something or other", and
2) you continue to use "D" and "H" unqualified, proving your dishonesty
and intent to equivocate.
So going forward, all uses of "H" and "D" in a sentence are required to
be qualified as either an algorithm, a function or a finite string.
Failure to do so will result in any sentence using such unqualified
usage to be dismissed out-of-hand as unclear.
On 11/6/2025 7:45 PM, olcott wrote:
On 11/6/2025 6:37 PM, dbush wrote:
On 11/6/2025 7:28 PM, olcott wrote:
On 11/6/2025 6:02 PM, dbush wrote:
On 11/6/2025 6:59 PM, olcott wrote:
On 11/6/2025 5:43 PM, dbush wrote:
On 11/6/2025 6:36 PM, olcott wrote:
On 11/6/2025 5:32 PM, dbush wrote:
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
That goes directly against your claims.On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>>>>I have know that for many years.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>>>>>>> D reaches a halt state.
You are beyond the pail.Only a correct, complete simulation of D coincides >>>>>>>>>>>>>>>>>>> with D's behavior.We don't give a rat's ass about the behavior of D. The >>>>>>>>>>>>>>>>>> input to H(D)
only specifies the behavior of D simulated by H. >>>>>>>>>>>>>>>>> Nobody cares about H.
Do you think that CS academics will buy the idea that >>>>>>>>>>>>>>>>>>> a simulating haltAbsolutely.
decider can leave a simulation object with unfinished >>>>>>>>>>>>>>>>>>> steps,
Now you only need to prove the correctness.such that those do not matter, and pronounce that >>>>>>>>>>>>>>>>>>> simulation to beAs soon as a non-terminating behavior pattern is >>>>>>>>>>>>>>>>>> correctly matched we
never ending?
are done.
They are going to ask the obvious question: what if >>>>>>>>>>>>>>>>>>> you take thatThat we be the same as asking are we sure that >>>>>>>>>>>>>>>>>> Infinite_Loop() never
simulation and peform more steps, surely it halts, so >>>>>>>>>>>>>>>>>>> the result was
wrong.
terminates?
It’s not the same. D halts when executed.
The is off topic because that is out-of-scope
for any termination analyzer.
False, because the input to H(D), i.e. finite string D >>>>>>>>>>>>>>> which is the description of machine D and therefore is >>>>>>>>>>>>>>> stipulated to specify all semantic properties of machine >>>>>>>>>>>>>>> D including that it halts when executed directly. >>>>>>>>>>>>>>>
It requires H to have the psychic powers to see >>>>>>>>>>>>>>>> steps that are not the steps that its actual input >>>>>>>>>>>>>>>> actually specifies.
False. As proven above, the steps that the actual input >>>>>>>>>>>>>>> to H(D) actually specifies are those of the directly >>>>>>>>>>>>>>> executed machine D.
If that was true then you could show the steps of D >>>>>>>>>>>>>> simulated by H reaching its simulated "return" statement >>>>>>>>>>>>>> nitwit. None of the moronic stopping and starting over >>>>>>>>>>>>>> bullshit.
That the input to H(D), i.e. the finite string description >>>>>>>>>>>>> of machine D, specifies all semantic properties of the >>>>>>>>>>>>> directly executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
You are getting close to being plonked.
It's not my fault you don't understand stipulative definitions. >>>>>>> Here's one:
Turing machine description: a finite string that specifies all
semantic properties of the machine being described.
Good you are being responsive. We can build an honest
dialogue on this basis.
Then you agree that
No you have to go back and read the rest of what I said.
On 4/2/22 6:43 PM, olcott wrote:
It is incorrect to disagree with stipulative definitions.
https://en.wikipedia.org/wiki/Stipulative_definition
;
Disagreeing with a stipulative definition is like disagreeing with
arithmetic.
*Unless a set of stipulative definitions disagrees with itself*
And you pointed out no such disagreement.
On 11/6/2025 6:50 PM, dbush wrote:
On 11/6/2025 7:45 PM, olcott wrote:
On 11/6/2025 6:37 PM, dbush wrote:
On 11/6/2025 7:28 PM, olcott wrote:
On 11/6/2025 6:02 PM, dbush wrote:
On 11/6/2025 6:59 PM, olcott wrote:
On 11/6/2025 5:43 PM, dbush wrote:
On 11/6/2025 6:36 PM, olcott wrote:
On 11/6/2025 5:32 PM, dbush wrote:
On 11/6/2025 6:12 PM, olcott wrote:
On 11/6/2025 5:00 PM, dbush wrote:
On 11/6/2025 5:55 PM, olcott wrote:
On 11/6/2025 4:35 PM, dbush wrote:
On 11/6/2025 5:32 PM, olcott wrote:
On 11/6/2025 4:26 PM, dbush wrote:
On 11/6/2025 5:16 PM, olcott wrote:
On 11/6/2025 4:07 PM, joes wrote:
Am Thu, 06 Nov 2025 15:32:51 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 11/6/2025 3:10 PM, Kaz Kylheku wrote: >>>>>>>>>>>>>>>>>>>> On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>>>>>
That goes directly against your claims.A partial simulation of D does not show whether (or >>>>>>>>>>>>>>>>>>>> not)I have know that for many years.
D reaches a halt state.
You are beyond the pail.Only a correct, complete simulation of D coincides >>>>>>>>>>>>>>>>>>>> with D's behavior.We don't give a rat's ass about the behavior of D. >>>>>>>>>>>>>>>>>>> The input to H(D)
only specifies the behavior of D simulated by H. >>>>>>>>>>>>>>>>>> Nobody cares about H.
Do you think that CS academics will buy the idea >>>>>>>>>>>>>>>>>>>> that a simulating haltAbsolutely.
decider can leave a simulation object with >>>>>>>>>>>>>>>>>>>> unfinished steps,
Now you only need to prove the correctness. >>>>>>>>>>>>>>>>>>such that those do not matter, and pronounce that >>>>>>>>>>>>>>>>>>>> simulation to beAs soon as a non-terminating behavior pattern is >>>>>>>>>>>>>>>>>>> correctly matched we
never ending?
are done.
They are going to ask the obvious question: what if >>>>>>>>>>>>>>>>>>>> you take thatThat we be the same as asking are we sure that >>>>>>>>>>>>>>>>>>> Infinite_Loop() never
simulation and peform more steps, surely it halts, >>>>>>>>>>>>>>>>>>>> so the result was
wrong.
terminates?
It’s not the same. D halts when executed. >>>>>>>>>>>>>>>>>>
The is off topic because that is out-of-scope >>>>>>>>>>>>>>>>> for any termination analyzer.
False, because the input to H(D), i.e. finite string D >>>>>>>>>>>>>>>> which is the description of machine D and therefore is >>>>>>>>>>>>>>>> stipulated to specify all semantic properties of machine >>>>>>>>>>>>>>>> D including that it halts when executed directly. >>>>>>>>>>>>>>>>
It requires H to have the psychic powers to see >>>>>>>>>>>>>>>>> steps that are not the steps that its actual input >>>>>>>>>>>>>>>>> actually specifies.
False. As proven above, the steps that the actual input >>>>>>>>>>>>>>>> to H(D) actually specifies are those of the directly >>>>>>>>>>>>>>>> executed machine D.
If that was true then you could show the steps of D >>>>>>>>>>>>>>> simulated by H reaching its simulated "return" statement >>>>>>>>>>>>>>> nitwit. None of the moronic stopping and starting over >>>>>>>>>>>>>>> bullshit.
That the input to H(D), i.e. the finite string description >>>>>>>>>>>>>> of machine D, specifies all semantic properties of the >>>>>>>>>>>>>> directly executed D is a semantic tautology.
In other words you are too fucking stupid to
show the actual steps.
It is a semantic tautology
It is not a semantic tautology
Disagreeing with a semantic tautology is always incorrect
You are getting close to being plonked.
It's not my fault you don't understand stipulative definitions. >>>>>>>> Here's one:
Turing machine description: a finite string that specifies all >>>>>>>> semantic properties of the machine being described.
Good you are being responsive. We can build an honest
dialogue on this basis.
Then you agree that
No you have to go back and read the rest of what I said.
On 4/2/22 6:43 PM, olcott wrote:
It is incorrect to disagree with stipulative definitions.
https://en.wikipedia.org/wiki/Stipulative_definition
;
Disagreeing with a stipulative definition is like disagreeing with >>>> > arithmetic.
*Unless a set of stipulative definitions disagrees with itself*
And you pointed out no such disagreement.
You were so damned sure that I was wrong that
you did not let me explain. Do you understand
how and that stipulative definitions can be incorrect?
It is incorrect to disagree with stipulative definitions. https://en.wikipedia.org/wiki/Stipulative_definition
Disagreeing with a stipulative definition is like disagreeing with arithmetic.
On 11/6/2025 7:51 PM, olcott wrote:
On 11/6/2025 6:49 PM, dbush wrote:
On 11/6/2025 7:44 PM, olcott wrote:
On 11/6/2025 6:36 PM, dbush wrote:
On 11/6/2025 7:30 PM, olcott wrote:
On 11/6/2025 6:05 PM, dbush wrote:
On 11/6/2025 7:01 PM, olcott wrote:
On 11/6/2025 5:52 PM, dbush wrote:
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:Is proving that the halting problem has always
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:Then you are admitting that what you're talking about >>>>>>>>>>>>>>
On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own >>>>>>>>>>>>>>>>>> simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>>>>> D reaches a halt state.
We are never taking about the directly executed D. >>>>>>>>>>>>>>>
been fundamentally incorrect in that it requires
Turing machines to have psychic powers to report
on a different sequence of steps than the sequence >>>>>>>>>>>>>> of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic >>>>>>>>>>>>> numbers to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in >>>>>>>>>>> wording for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
Only if you are clueless about the semantics
of the C programming language.
The posted code contains function D, algorithm D, and finite
string D, and similarly for "H". So the above sentence could be >>>>>>> referring to any of those.
DO YOU HAVE A MENTAL DISABILITY
THAT CAUSES YOU TO IMMEDIATELY FORGET
WHAT WAS JUST EXPLAINED TO YOU?
I am not going to endlessly repeat all
of the details if you are just being a jackass.
All you have to do to prove you're interested in an honest dialogue >>>>> is to fix the above sentence
by qualifying each instance of "D" and "H" in the above sentence
with exactly one of:
* C function
* algorithm
* finite string
Only liars refuse to clarify their statements.
I already fully addressed this twice.
Only jackasses or people with mental
disabilities ignore complete answers
and keep asking the same question.
There was no complete answer because
I completely defined D twice and you did
not revise your question to account for this.
As per the below requirements, the above sentence is rejected out-of-
hand as unclear because "D" was not qualified as either a C function, algorithm, or finite string.
Are you a jackass or do you have mental
disabilities?
1) you referred to "H" as "something or other", and
2) you continue to use "D" and "H" unqualified, proving your
dishonesty and intent to equivocate.
So going forward, all uses of "H" and "D" in a sentence are required
to be qualified as either an algorithm, a function or a finite string.
Failure to do so will result in any sentence using such unqualified
usage to be dismissed out-of-hand as unclear.
On 11/6/2025 6:54 PM, dbush wrote:
On 11/6/2025 7:51 PM, olcott wrote:
On 11/6/2025 6:49 PM, dbush wrote:
On 11/6/2025 7:44 PM, olcott wrote:
On 11/6/2025 6:36 PM, dbush wrote:
On 11/6/2025 7:30 PM, olcott wrote:
On 11/6/2025 6:05 PM, dbush wrote:
On 11/6/2025 7:01 PM, olcott wrote:
On 11/6/2025 5:52 PM, dbush wrote:
On 11/6/2025 6:45 PM, olcott wrote:
On 11/6/2025 5:35 PM, dbush wrote:
On 11/6/2025 6:08 PM, olcott wrote:
On 11/6/2025 4:58 PM, dbush wrote:
On 11/6/2025 5:52 PM, olcott wrote:
On 11/6/2025 4:27 PM, dbush wrote:
On 11/6/2025 5:24 PM, olcott wrote:Is proving that the halting problem has always
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:Then you are admitting that what you're talking about >>>>>>>>>>>>>>>
On 2025-11-06, olcott <[email protected]> wrote: >>>>>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own >>>>>>>>>>>>>>>>>>> simulated final halt state.
"Simulation of D" and "D" are not the same. >>>>>>>>>>>>>>>>>>
A partial simulation of D does not show whether (or not) >>>>>>>>>>>>>>>>>> D reaches a halt state.
We are never taking about the directly executed D. >>>>>>>>>>>>>>>>
been fundamentally incorrect in that it requires >>>>>>>>>>>>>>> Turing machines to have psychic powers to report >>>>>>>>>>>>>>> on a different sequence of steps than the sequence >>>>>>>>>>>>>>> of steps that its input actually specifies.
False. Just like it is not incorrect to require Mythic >>>>>>>>>>>>>> numbers to be
You cannot truthfully assess this as false
UNTIL AFTER YOU HAVE HEARD ALL OF MY POINTS.
You've been saying the same points with slight variations in >>>>>>>>>>>> wording for the last 3 years.
Because I cannot move on to the second step of
my proof until the first step is understood.
The first step of my proof is that D simulated
by H cannot reach its own simulated "return"
statement.
Rejected out-of-hand as unclear,
Only if you are clueless about the semantics
of the C programming language.
The posted code contains function D, algorithm D, and finite
string D, and similarly for "H". So the above sentence could be >>>>>>>> referring to any of those.
DO YOU HAVE A MENTAL DISABILITY
THAT CAUSES YOU TO IMMEDIATELY FORGET
WHAT WAS JUST EXPLAINED TO YOU?
I am not going to endlessly repeat all
of the details if you are just being a jackass.
All you have to do to prove you're interested in an honest
dialogue is to fix the above sentence
by qualifying each instance of "D" and "H" in the above sentence
with exactly one of:
* C function
* algorithm
* finite string
Only liars refuse to clarify their statements.
I already fully addressed this twice.
Only jackasses or people with mental
disabilities ignore complete answers
and keep asking the same question.
There was no complete answer because
I completely defined D twice and you did
not revise your question to account for this.
As per the below requirements, the above sentence is rejected out-of-
hand as unclear because "D" was not qualified as either a C function,
algorithm, or finite string.
I did explain exactly what D is in great detail.
*plonked*
Are you a jackass or do you have mental
disabilities?
1) you referred to "H" as "something or other", and
2) you continue to use "D" and "H" unqualified, proving your
dishonesty and intent to equivocate.
So going forward, all uses of "H" and "D" in a sentence are required
to be qualified as either an algorithm, a function or a finite string. >>>>
Failure to do so will result in any sentence using such unqualified
usage to be dismissed out-of-hand as unclear.
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Try again.
On 2025-11-06, olcott <[email protected]> wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Try again.
Objectively, outside of any cult-like dogma, there is only one D.
The directly executed D is exactly the same as
On 2025-11-05, olcott <[email protected]> wrote:
The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.
Yes; this doesn't happen while H is running.
So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence
can refer to a C function, an algorithm, or a finite string, and the
meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides
into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
You can monkey around with all kinds of screwy
stuff to get gullible people here to believe
that infinite loops halt.
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence
can refer to a C function, an algorithm, or a finite string, and the
meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides
into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider
which is jsut a UTM. Ih the language of our "concrete example" it does
this:
bool H_prime(void (*P)(void), interp *s) // using new API
{
while (!interp_step(s)) { }
return true;
}
and D' is this: it looks similar to D, but calls H':
void D_prime(void)
{
interp *s = interp_init(D_prime);
if (H_prime(D_prime, s)) { for (;;) }
return;
}
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim that
D is nonterminating, because D' is nonterminating. You claim that the H decision is correct because it should be interpreted as being really
about D'.
Yet, at the same time, you vehemently insist that the input to H
is D simulated by H, and not the directly executed D,
because H only operates on the "finite string that is its
actual input".
What you actually mean is that the true input to H is
D'!
That's the function that does not terminate: D' is what we would
get if H were not to abort, because H would then be H'.
D' is /literally/ not an input to H; it is different from D,
right from its first step. D' calls H'(D'), wheras D calls H(D).
I don't agree that the input to H(D) is actually D'.
Somewhat separately from that, I don't agree that D' could ever be
considered the finite string input
in the expression H(D), since D and
D' are different and unrelated.
I.e. you say that the true finite string input in H(D) is "the behavior
of D simulated by H". But the decision is actually about D', which has nothing to do with "D simulated by H".
I don't misunderstand; I just deny that what you are proposing
is "philosophically okay".
You can monkey around with all kinds of screwy
stuff to get gullible people here to believe
that infinite loops halt.
But the halting of the diagonal cases
rejected by their simulating
decider has been reproduced with the x86utm.
Mike Terry even produced a clean HHH and DD pair of test cases which eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of D simulations starting up --- and individually terminating.
Exactly was was predicted in discussions.
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence >>>>> can refer to a C function, an algorithm, or a finite string, and the >>>>> meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides
into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider
which is jsut a UTM. Ih the language of our "concrete example" it does
this:
Not exactly. Your H is a UTM in a for loop.
This by itself proves the repeating pattern
that prevents D simulated by H to ever reach
its own simulated "return" statement.
bool H_prime(void (*P)(void), interp *s) // using new API
{
while (!interp_step(s)) { }
return true;
}
and D' is this: it looks similar to D, but calls H':
void D_prime(void)
{
interp *s = interp_init(D_prime);
if (H_prime(D_prime, s)) { for (;;) }
return;
}
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim that
D is nonterminating, because D' is nonterminating. You claim that the H
decision is correct because it should be interpreted as being really
about D'.
I have no idea what you are saying here.
Yet, at the same time, you vehemently insist that the input to H
is D simulated by H, and not the directly executed D,
because H only operates on the "finite string that is its
actual input".
Yes this has been a verified fact for three years.
What you actually mean is that the true input to H is
In the updated version a finite string of ASCII characters
that defines a C function that calls its own C interpreter.
D'!
That's the function that does not terminate: D' is what we would
get if H were not to abort, because H would then be H'.
D' is /literally/ not an input to H; it is different from D,
right from its first step. D' calls H'(D'), wheras D calls H(D).
I don't agree that the input to H(D) is actually D'.
Somewhat separately from that, I don't agree that D' could ever be
considered the finite string input
Then you are rejecting reality.
in the expression H(D), since D and
D' are different and unrelated.
I.e. you say that the true finite string input in H(D) is "the behavior
of D simulated by H". But the decision is actually about D', which has
nothing to do with "D simulated by H".
When you ask Mary a yes/no question she is not
in a different parallel universe depending on
her answer.
I don't misunderstand; I just deny that what you are proposing
is "philosophically okay".
You can monkey around with all kinds of screwy
stuff to get gullible people here to believe
that infinite loops halt.
But the halting of the diagonal cases
Hides all of the details, it should actually be
called halting in all of the "do the opposite" cases.
rejected by their simulating
decider has been reproduced with the x86utm.
Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
Mike Terry understands my code better than anyone
else he seems to have a total blind spot about key
elements of my algorithm.
He actually observed the start of the tower; seeing numerous levels of D
simulations starting up --- and individually terminating.
That only happens when you screw up the specified
execution trace.
It flat out nutty to do anything at all besides reject
an input when the behavior OF THIS INPUT CORRECTLY MATCHES
A CORRECT NON-HALTING BEHAVIOR PATTERN.
It just seems like you and Mike fail to understand
CORRECT NON-HALTING BEHAVIOR PATTERNS.
Exactly was was predicted in discussions.
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence
can refer to a C function, an algorithm, or a finite string, and the
meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides
into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider
which is jsut a UTM. Ih the language of our "concrete example" it does
this:
bool H_prime(void (*P)(void), interp *s) // using new API
{
while (!interp_step(s)) { }
return true;
}
and D' is this: it looks similar to D, but calls H':
void D_prime(void)
{
interp *s = interp_init(D_prime);
if (H_prime(D_prime, s)) { for (;;) }
return;
}
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'.
And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim that
D is nonterminating, because D' is nonterminating. You claim that the H decision is correct because it should be interpreted as being really
about D'.
Yet, at the same time, you vehemently insist that the input to H
is D simulated by H, and not the directly executed D,
because H only operates on the "finite string that is its
actual input".
What you actually mean is that the true input to H is D'!
That's the function that does not terminate: D' is what we would
get if H were not to abort, because H would then be H'.
D' is /literally/ not an input to H; it is different from D,
right from its first step. D' calls H'(D'), wheras D calls H(D).
I don't agree that the input to H(D) is actually D'.
Somewhat separately from that, I don't agree that D' could ever be
considered the finite string input in the expression H(D), since D and
D' are different and unrelated.
I.e. you say that the true finite string input in H(D) is "the behavior
of D simulated by H". But the decision is actually about D', which has nothing to do with "D simulated by H".
I don't misunderstand; I just deny that what you are proposing
is "philosophically okay".
You can monkey around with all kinds of screwy
stuff to get gullible people here to believe
that infinite loops halt.
But the halting of the diagonal cases rejected by their simulating
decider has been reproduced with the x86utm.
Mike Terry even produced a clean HHH and DD pair of test cases which eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of D simulations starting up --- and individually terminating.
Exactly was was predicted in discussions.
On 11/6/2025 7:22 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
On 11/6/2025 3:10 PM, Kaz Kylheku wrote:
On 2025-11-06, olcott <[email protected]> wrote:
D simulated by H cannot possibly reach its own
simulated final halt state.
"Simulation of D" and "D" are not the same.
A partial simulation of D does not show whether (or not)
D reaches a halt state.
We are never taking about the directly executed D.
Try again.
Objectively, outside of any cult-like dogma, there is only one D.
The directly executed D is exactly the same as
You already agreed that it is not.
On 11/4/2025 8:43 PM, Kaz Kylheku wrote:
On 2025-11-05, olcott <[email protected]> wrote:
The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.
Yes; this doesn't happen while H is running.
So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence >>>>> can refer to a C function, an algorithm, or a finite string, and the >>>>> meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides
into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider
which is jsut a UTM. Ih the language of our "concrete example" it does
this:
bool H_prime(void (*P)(void), interp *s) // using new API
{
while (!interp_step(s)) { }
return true;
}
and D' is this: it looks similar to D, but calls H':
void D_prime(void)
{
interp *s = interp_init(D_prime);
if (H_prime(D_prime, s)) { for (;;) }
return;
}
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'.
I changed it from halting versus non-halting a long
time ago to avoid screwy weasel wording.
D simulated
by H cannot possibly reach its own simulated "return"
statement.
Software engineers knowing nothing about
comp.theory can and have verified that.
We can even say that we refer to the outermost D
directly simulated by the directly executed H. All
the D versus D' crap is merely misleading, it has
no actual substance.
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence >>>>> can refer to a C function, an algorithm, or a finite string, and the >>>>> meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides
into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider
which is jsut a UTM. Ih the language of our "concrete example" it does
this:
bool H_prime(void (*P)(void), interp *s) // using new API
{
while (!interp_step(s)) { }
return true;
}
and D' is this: it looks similar to D, but calls H':
void D_prime(void)
{
interp *s = interp_init(D_prime);
if (H_prime(D_prime, s)) { for (;;) }
return;
}
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'.
I changed it from halting versus non-halting a long
time ago to avoid screwy weasel wording. D simulated
by H cannot possibly reach its own simulated "return"
statement. Software engineers knowing nothing about
comp.theory can and have verified that.
We can even say that we refer to the outermost D
directly simulated by the directly executed H. All
the D versus D' crap is merely misleading, it has
no actual substance.
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence >>>>>> can refer to a C function, an algorithm, or a finite string, and the >>>>>> meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides >>>>> into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider
which is jsut a UTM. Ih the language of our "concrete example" it does
this:
bool H_prime(void (*P)(void), interp *s) // using new API
{
while (!interp_step(s)) { }
return true;
}
and D' is this: it looks similar to D, but calls H':
void D_prime(void)
{
interp *s = interp_init(D_prime);
if (H_prime(D_prime, s)) { for (;;) }
return;
}
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'.
I changed it from halting versus non-halting a long
time ago to avoid screwy weasel wording. D simulated
by H cannot possibly reach its own simulated "return"
statement. Software engineers knowing nothing about
comp.theory can and have verified that.
The simualtion D, while being simulated by H, will never
On 11/6/2025 9:59 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above
sentence
can refer to a C function, an algorithm, or a finite string, and the >>>>>>> meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides >>>>>> into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider >>>> which is jsut a UTM. Ih the language of our "concrete example" it does >>>> this:
bool H_prime(void (*P)(void), interp *s) // using new API
{
while (!interp_step(s)) { }
return true;
}
and D' is this: it looks similar to D, but calls H':
void D_prime(void)
{
interp *s = interp_init(D_prime);
if (H_prime(D_prime, s)) { for (;;) }
return;
}
In D_prime, the H_prime call does not return. It never reaches its the >>>> "do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'.
I changed it from halting versus non-halting a long
time ago to avoid screwy weasel wording. D simulated
by H cannot possibly reach its own simulated "return"
statement. Software engineers knowing nothing about
comp.theory can and have verified that.
The simualtion D, while being simulated by H, will never
reach its own simulated "return" statement final halt
state because it remains stuck in recursive simulation
until H kills its whole process.
Erasing the immediate context that you are
responding to is deceitful and dishonest.
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence >>>>> can refer to a C function, an algorithm, or a finite string, and the >>>>> meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides
into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider
which is jsut a UTM. Ih the language of our "concrete example" it does
this:
Not exactly. Your H is a UTM in a for loop.
This by itself proves the repeating pattern
that prevents D simulated by H to ever reach
its own simulated "return" statement.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim that
D is nonterminating, because D' is nonterminating. You claim that the H
decision is correct because it should be interpreted as being really
about D'.
I have no idea what you are saying here.
Yet, at the same time, you vehemently insist that the input to H
is D simulated by H, and not the directly executed D,
because H only operates on the "finite string that is its
actual input".
Yes this has been a verified fact for three years.
What you actually mean is that the true input to H is
In the updated version a finite string of ASCII characters
that defines a C function that calls its own C interpreter.
D'!
That's the function that does not terminate: D' is what we would
get if H were not to abort, because H would then be H'.
D' is /literally/ not an input to H; it is different from D,
right from its first step. D' calls H'(D'), wheras D calls H(D).
I don't agree that the input to H(D) is actually D'.
Somewhat separately from that, I don't agree that D' could ever be
considered the finite string input
Then you are rejecting reality.
in the expression H(D), since D and
D' are different and unrelated.
I.e. you say that the true finite string input in H(D) is "the behavior
of D simulated by H". But the decision is actually about D', which has
nothing to do with "D simulated by H".
When you ask Mary a yes/no question she is not
in a different parallel universe depending on
her answer.
Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
Mike Terry understands my code better than anyone
else he seems to have a total blind spot about key
elements of my algorithm.
He actually observed the start of the tower; seeing numerous levels of D
simulations starting up --- and individually terminating.
That only happens when you screw up the specified
execution trace.
It flat out nutty to do anything at all besides reject
an input when the behavior OF THIS INPUT CORRECTLY MATCHES
A CORRECT NON-HALTING BEHAVIOR PATTERN.
It just seems like you and Mike fail to understand
CORRECT NON-HALTING BEHAVIOR PATTERNS.
Exactly was was predicted in discussions.
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above sentence >>>>>> can refer to a C function, an algorithm, or a finite string, and the >>>>>> meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides >>>>> into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider
which is jsut a UTM. Ih the language of our "concrete example" it does
this:
Not exactly. Your H is a UTM in a for loop.
No; my H has a for loop which steps three instructions after
which it returns false.
This by itself proves the repeating pattern
that prevents D simulated by H to ever reach
its own simulated "return" statement.
D' simulated by H' never reaches its return statement.
On 11/6/2025 10:16 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
On 2025-11-07, olcott <[email protected]> wrote:
On 11/6/2025 6:00 PM, Kaz Kylheku wrote:
On 2025-11-06, dbush <[email protected]> wrote:
Rejected out-of-hand as unclear, as "D" and "H" in the above
sentence
can refer to a C function, an algorithm, or a finite string, and the >>>>>>> meaning changes depending on which one is chosen.
Your concrete example is brilliant I am going
to rebuild something very similar on the basis
of a C interpreter.
Not only to that. "D" can refer to "simulation of D" which subdivides >>>>>> into "partial simulation of D" and "complete simulation of D".
That has always been crazy nonsense. It has only
always been the single continuous simulation
of D by H that proves that D cannot possibly halt.
No, what doesn't halt is H' simulating D'. H' is a different decider >>>> which is jsut a UTM. Ih the language of our "concrete example" it does >>>> this:
Not exactly. Your H is a UTM in a for loop.
No; my H has a for loop which steps three instructions after
which it returns false.
This by itself proves the repeating pattern
that prevents D simulated by H to ever reach
its own simulated "return" statement.
D' simulated by H' never reaches its return statement.
Most importantly the D directly simulated by the executed
H never reaches its own "return" statement. All the rest
is weasel word deflection away from this point.
So going forward, all uses of "H" and "D" in a sentence are required to
be qualified as either an algorithm, a function or a finite string.
Failure to do so will result in any sentence using such unqualified
usage to be dismissed out-of-hand as unclear.
Since D is built on H, the imaginary H' gives rise to an imaginary D
that must be called D' since it is different from D.
If we use the names D and H for D' and H', we are equivocating and
promoting muddled thinking.
THAT equivocation is what has no substance!!!
That equivocation is, in great part, what allows you to stitch together
your invalid rhetoric.
Your rhetoric doesn't hold when we unmask the equivocation
identify all the abstractions that are referenced in it and give
them different names.
D simulated by H cannot possibly reach its own
simulated final halt state.
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:No, it is bounded.
No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its theI have no idea what you are saying here.
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being
really about D'.
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
When you ask Mary a yes/no question she is not in a different parallel universe depending on her answer.You think she can answer both at once?
You haven’t shown that. H could easily save the state of the simulation, return 0, and later you call a UTM with the saved state, which then halts.Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of
D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.
It flat out nutty to do anything at all besides reject an input when the behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR PATTERN.Your pattern is not correct, because it ignores that D calls the
It just seems like you and Mike fail to understand CORRECT NON-HALTING BEHAVIOR PATTERNS.
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
No, it is bounded.No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its theI have no idea what you are saying here.
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being
really about D'.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of
D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.You haven’t shown that. H could easily save the state of the simulation, return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the
halting H.
You think that D runs forever because it calls the non-
decider H. There can be no correct patterns in the diagonal case.
Every fix to the detection logic gives rise to a new program that
doesn’t match it.
On 2025-11-06 20:48:02 +0000, olcott said:
D simulated by H cannot possibly reach its own
simulated final halt state.
That is merely a defect in H and irrelevanto to the semantic and other properties of D.
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
No, it is bounded.No, what doesn't halt is H' simulating D'. H' is a different decider which is just a UTM. Ih the language of our "concrete example" it does this:Not exactly. Your H is a UTM in a for loop.
In D_prime, the H_prime call does not return. It never reaches its the "do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is nonterminating, it is somehow "philosophically okay" for H to claim that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being really about D'.
I have no idea what you are saying here.
Yes, what’s giving you trouble?
Then its the wrong 'H'. Read the Halting Problem carefully.If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever be considered the finite string inputThen you are rejecting reality.
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallel universe depending on her answer.You think she can answer both at once?
Mike Terry even produced a clean HHH and DD pair of test cases which eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.You haven’t shown that. H could easily save the state of the simulation, return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the
halting H.
D simulated by the executed H does not call any halting H.
Ask all LLM's, they are not responsible for their answer.You think that D runs forever because it calls the non-
decider H. There can be no correct patterns in the diagonal case.
If this is your most fundamental belief it may seem
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Every fix to the detection logic gives rise to a new program that
doesn’t match it.
int D()If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
Until H aborts.Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no oneOnly you the idiot do not understand what program is.
here understands. I have been programming
in C since K & R was the standard.
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:No, it is bounded.
No, what doesn't halt is H' simulating D'. H' is a different decider >>>>> which is just a UTM. Ih the language of our "concrete example" it does >>>>> this:Not exactly. Your H is a UTM in a for loop.
In D_prime, the H_prime call does not return. It never reaches its the >>>>> "do opposite" logic. We completely agree!I have no idea what you are saying here.
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim that >>>>> the H decision is correct because it should be interpreted as being
really about D'.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s not >>> a single function/program with a definite halting status.What you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines >>>> a C function that calls its own C interpreter.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallel >>>> universe depending on her answer.You think she can answer both at once?
You haven’t shown that. H could easily save the state of the simulation, >>> return 0, and later you call a UTM with the saved state, which then halts. >>>Mike Terry even produced a clean HHH and DD pair of test cases which >>>>> eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of >>>>> D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.
It flat out nutty to do anything at all besides reject an input when the >>>> behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR >>>> PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING >>>> BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the
halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the result, not something else.
You think that D runs forever because it calls the non-
decider H. There can be no correct patterns in the diagonal case.
If this is your most fundamental belief it may seem
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that
doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your
head is harder than the stone (and the chick is thicker than steel).
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
No, it is bounded.No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/, H were not to abort the simulation of D, then it would turn into H' and therefore D would turn into D'. And because that D' is nonterminating, it is somehow "philosophically okay" for H to claim that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being really about D'.
I have no idea what you are saying here.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever be considered the finite string inputThen you are rejecting reality.
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of
D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.You haven’t shown that. H could easily save the state of the simulation,
return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the result, not something else.
You think that D runs forever because it calls the non-
decider H. There can be no correct patterns in the diagonal case.
If this is your most fundamental belief it may seem
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your
head is harder than the stone (and the chick is thicker than steel).
When we start with the semantics of the C programmingSo the correct answer of Halting Problem is undecidable. Agree.
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
On 11/7/2025 4:45 AM, joes wrote:Apparently so, see below.
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
Is that what you mean? H replaces the call from D to H with a call to aSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
UTM and simulates that?
Interesting. Then D is not the diagonal program and H is not a decider.Your pattern is not correct, because it ignores that D calls theD simulated by the executed H does not call any halting H.
halting H.
Do you really think both that H is a decider, D calling H doesn’t haltYou think that D runs forever because it calls the non-If this is your most fundamental belief it may seem that way. Four LLM systems now understand my system and they figured it out on their own
decider H. There can be no correct patterns in the diagonal case.
and proved that they are correct.
And then the first H aborts instead of simulating simulating (sic)Every fix to the detection logic gives rise to a new program thatH simulates D that calls H(D)
doesn’t match it.
that simulates D that calls H(D)
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:No, it is bounded.
No, what doesn't halt is H' simulating D'. H' is a different decider >>>>>>> which is just a UTM. Ih the language of our "concrete example" it does >>>>>>> this:Not exactly. Your H is a UTM in a for loop.
In D_prime, the H_prime call does not return. It never reaches its the >>>>>>> "do opposite" logic. We completely agree!I have no idea what you are saying here.
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/, >>>>>>> H were not to abort the simulation of D, then it would turn into H' >>>>>>> and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim >>>>>>> that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being >>>>>>> really about D'.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s not >>>>> a single function/program with a definite halting status.What you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines >>>>>> a C function that calls its own C interpreter.
Is that what you mean? H replaces the call from D to H with a call to >>>>> a UTM and simulates that?Somewhat separately from that, I don't agree that D' could ever be >>>>>>> considered the finite string inputThen you are rejecting reality.
When you ask Mary a yes/no question she is not in a different parallel >>>>>> universe depending on her answer.You think she can answer both at once?
You haven’t shown that. H could easily save the state of the simulation,Mike Terry even produced a clean HHH and DD pair of test cases which >>>>>>> eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of >>>>>>> D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.
return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the >>>>>> behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR >>>>>> PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING >>>>>> BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the
halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the >>> result, not something else.
You think that D runs forever because it calls the non-
decider H. There can be no correct patterns in the diagonal case.
If this is your most fundamental belief it may seem
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that
doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your
head is harder than the stone (and the chick is thicker than steel).
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree.
Am Fri, 07 Nov 2025 06:55:49 -0600 schrieb olcott:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
Apparently so, see below.Is that what you mean? H replaces the call from D to H with a call to aSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
UTM and simulates that?
Interesting. Then D is not the diagonal program and H is not a decider.Your pattern is not correct, because it ignores that D calls theD simulated by the executed H does not call any halting H.
halting H.
Which H does D call? The one in the code halts.
Do you really think both that H is a decider, D calling H doesn’t haltYou think that D runs forever because it calls the non-If this is your most fundamental belief it may seem that way. Four LLM
decider H. There can be no correct patterns in the diagonal case.
systems now understand my system and they figured it out on their own
and proved that they are correct.
and D is the diagonal program to H? One of those can’t be right.
And then the first H aborts instead of simulating simulating (sic)Every fix to the detection logic gives rise to a new program thatH simulates D that calls H(D)
doesn’t match it.
that simulates D that calls H(D)
this H simulating D. This last H isn’t simulated at all, it is just
assumed to not be a decider.
On 11/7/2025 8:12 AM, wij wrote:
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
No, it is bounded.No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being
really about D'.
I have no idea what you are saying here.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of
D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.You haven’t shown that. H could easily save the state of the simulation,
return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the
result, not something else.
You think that D runs forever because it calls the non-
decider H. There can be no correct patterns in the diagonal case.
If this is your most fundamental belief it may seem
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your head is harder than the stone (and the chick is thicker than steel).
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree.
It might seem that way if you didn't understandYou are false god. What you said is garbage.
a word that I just said
and don't know anythingNo one here (except you) who need debugger to explain C 'semantic'.
about programming in C.
On Fri, 2025-11-07 at 08:28 -0600, olcott wrote:
On 11/7/2025 8:12 AM, wij wrote:
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:No, it is bounded.
No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its theI have no idea what you are saying here.
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/, >>>>>>>>> H were not to abort the simulation of D, then it would turn into H' >>>>>>>>> and therefore D would turn into D'. And because that D' is >>>>>>>>> nonterminating, it is somehow "philosophically okay" for H to claim >>>>>>>>> that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being >>>>>>>>> really about D'.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call to >>>>>>> a UTM and simulates that?Somewhat separately from that, I don't agree that D' could ever be >>>>>>>>> considered the finite string inputThen you are rejecting reality.
When you ask Mary a yes/no question she is not in a different parallel >>>>>>>> universe depending on her answer.You think she can answer both at once?
return 0, and later you call a UTM with the saved state, which then halts.Mike Terry even produced a clean HHH and DD pair of test cases which >>>>>>>>> eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of
D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace. >>>>>>> You haven’t shown that. H could easily save the state of the simulation,
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING >>>>>>>> BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the >>>>>>> halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the
result, not something else.
You think that D runs forever because it calls the non-If this is your most fundamental belief it may seem
decider H. There can be no correct patterns in the diagonal case. >>>>>>
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that >>>>>>> doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your >>>>> head is harder than the stone (and the chick is thicker than steel). >>>>>
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree.
It might seem that way if you didn't understand
a word that I just said
You are false god. What you said is garbage.
and don't know anything
about programming in C.
No one here (except you) who need debugger to explain C 'semantic'.
And see the assembly dump as 'proof'. Wake up, idiot.
On 11/7/2025 8:35 AM, wij wrote:
On Fri, 2025-11-07 at 08:28 -0600, olcott wrote:
On 11/7/2025 8:12 AM, wij wrote:
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
No, it is bounded.No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being
really about D'.
I have no idea what you are saying here.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of
D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.You haven’t shown that. H could easily save the state of the simulation,
return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the
halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the
result, not something else.
You think that D runs forever because it calls the non-
decider H. There can be no correct patterns in the diagonal case.
If this is your most fundamental belief it may seem
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that
doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your
head is harder than the stone (and the chick is thicker than steel).
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree.
It might seem that way if you didn't understand
a word that I just said
You are false god. What you said is garbage.
and don't know anything
about programming in C.
No one here (except you) who need debugger to explain C 'semantic'.
And see the assembly dump as 'proof'. Wake up, idiot.
If I was incorrect then you could show whatFirst of all, the correct halt decider does not exist. We can only 'experiment' by assumptions.... But you know the liar's paradox well, so I save this.
the correct execution trace should be.
IfSure, you can ignore all and believe garbage.
you lack the skill to show this and still
want to disagree then you can be ignored.
On 11/7/2025 8:55 AM, wij wrote:
On Fri, 2025-11-07 at 08:38 -0600, olcott wrote:
On 11/7/2025 8:35 AM, wij wrote:
On Fri, 2025-11-07 at 08:28 -0600, olcott wrote:
On 11/7/2025 8:12 AM, wij wrote:
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
No, it is bounded.No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being
really about D'.
I have no idea what you are saying here.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of
D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.You haven’t shown that. H could easily save the state of the simulation,
return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the
halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the
result, not something else.
You think that D runs forever because it calls the non- decider H. There can be no correct patterns in the diagonal case.
If this is your most fundamental belief it may seem
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that
doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts), D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your
head is harder than the stone (and the chick is thicker than steel).
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree.
It might seem that way if you didn't understand
a word that I just said
You are false god. What you said is garbage.
and don't know anything
about programming in C.
No one here (except you) who need debugger to explain C 'semantic'.
And see the assembly dump as 'proof'. Wake up, idiot.
I have no problem of "D simulated by (POO) H", except if you claim the HP proof is refuted is a big problem.If I was incorrect then you could show what
the correct execution trace should be.
First of all, the correct halt decider does not exist.
Changing the subject is known as the strawman deception
it is what cheaters do when they have no actual rebuttal
and still want to be disagreeable.
I am only talking about D simulated by H.
We can only 'experiment'
by assumptions.... But you know the liar's paradox well, so I save this.
If you refer to POOH, no one can reproduce POOH, POOH is considered as non-existent.
I have a bunch of steps if you reject the firstSave it. I already had clue what your next steps is .... garbage.
step out-of-hand because you don't understand C
then we can't move on to the next step.
If
you lack the skill to show this and still
want to disagree then you can be ignored.
Sure, you can ignore all and believe garbage.
That you don't even understand what I am sayingI understand what you say (which bears no meaning).
is not my error.
On Fri, 2025-11-07 at 09:06 -0600, olcott wrote:
On 11/7/2025 8:55 AM, wij wrote:
On Fri, 2025-11-07 at 08:38 -0600, olcott wrote:
On 11/7/2025 8:35 AM, wij wrote:
On Fri, 2025-11-07 at 08:28 -0600, olcott wrote:
On 11/7/2025 8:12 AM, wij wrote:
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:No, it is bounded.
No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its theI have no idea what you are saying here.
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is >>>>>>>>>>>>> nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being
really about D'.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'! >>>>>>>>>>>> In the updated version a finite string of ASCII characters that definesa C function that calls its own C interpreter.
a single function/program with a definite halting status. >>>>>>>>>>>
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
return 0, and later you call a UTM with the saved state, which then halts.Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels ofThat only happens when you screw up the specified execution trace. >>>>>>>>>>> You haven’t shown that. H could easily save the state of the simulation,
D simulations starting up --- and individually terminating. >>>>>>>>>>>
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the >>>>>>>>>>> halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the
result, not something else.
You think that D runs forever because it calls the non-If this is your most fundamental belief it may seem
decider H. There can be no correct patterns in the diagonal case. >>>>>>>>>>
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that >>>>>>>>>>> doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts), >>>>>>>>> D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D. >>>>>>>>>
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your
head is harder than the stone (and the chick is thicker than steel). >>>>>>>>>
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree.
It might seem that way if you didn't understand
a word that I just said
You are false god. What you said is garbage.
and don't know anything
about programming in C.
No one here (except you) who need debugger to explain C 'semantic'.
And see the assembly dump as 'proof'. Wake up, idiot.
If I was incorrect then you could show what
the correct execution trace should be.
First of all, the correct halt decider does not exist.
Changing the subject is known as the strawman deception
it is what cheaters do when they have no actual rebuttal
and still want to be disagreeable.
I am only talking about D simulated by H.
I have no problem of "D simulated by (POO) H", except if you claim the HP proof
is refuted is a big problem.
As to the constantly changing POOH, many people have already explained to you.
We can only 'experiment'
by assumptions.... But you know the liar's paradox well, so I save this. >>>
If you refer to POOH, no one can reproduce POOH, POOH is considered as non-existent.
I have a bunch of steps if you reject the first
step out-of-hand because you don't understand C
then we can't move on to the next step.
Save it. I already had clue what your next steps is .... garbage.
If
you lack the skill to show this and still
want to disagree then you can be ignored.
Sure, you can ignore all and believe garbage.
That you don't even understand what I am saying
is not my error.
I understand what you say (which bears no meaning).
On 11/7/2025 9:17 AM, wij wrote:
On Fri, 2025-11-07 at 09:06 -0600, olcott wrote:
On 11/7/2025 8:55 AM, wij wrote:
On Fri, 2025-11-07 at 08:38 -0600, olcott wrote:
On 11/7/2025 8:35 AM, wij wrote:
On Fri, 2025-11-07 at 08:28 -0600, olcott wrote:
On 11/7/2025 8:12 AM, wij wrote:
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
No, it is bounded.No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being
really about D'.
I have no idea what you are saying here.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of
D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.You haven’t shown that. H could easily save the state of the simulation,
return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the
halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the
result, not something else.
You think that D runs forever because it calls the non- decider H. There can be no correct patterns in the diagonal case.
If this is your most fundamental belief it may seem
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that
doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your
head is harder than the stone (and the chick is thicker than steel).
When we start with the semantics of the C programming language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree.
It might seem that way if you didn't understand
a word that I just said
You are false god. What you said is garbage.
and don't know anything
about programming in C.
No one here (except you) who need debugger to explain C 'semantic'. And see the assembly dump as 'proof'. Wake up, idiot.
If I was incorrect then you could show what
the correct execution trace should be.
First of all, the correct halt decider does not exist.
Changing the subject is known as the strawman deception
it is what cheaters do when they have no actual rebuttal
and still want to be disagreeable.
I am only talking about D simulated by H.
I have no problem of "D simulated by (POO) H", except if you claim the HP proof
is refuted is a big problem.
As to the constantly changing POOH, many people have already explained to you.
So you accept that D simulated by H cannot possiblyRepeat:
reach its own simulated "return" statement?
We can only 'experiment'
by assumptions.... But you know the liar's paradox well, so I save this.
If you refer to POOH, no one can reproduce POOH, POOH is considered as non-existent.
I have a bunch of steps if you reject the first
step out-of-hand because you don't understand C
then we can't move on to the next step.
Save it. I already had clue what your next steps is .... garbage.
If
you lack the skill to show this and still
want to disagree then you can be ignored.
Sure, you can ignore all and believe garbage.
That you don't even understand what I am saying
is not my error.
I understand what you say (which bears no meaning).
On Fri, 2025-11-07 at 09:20 -0600, olcott wrote:
On 11/7/2025 9:17 AM, wij wrote:
On Fri, 2025-11-07 at 09:06 -0600, olcott wrote:
On 11/7/2025 8:55 AM, wij wrote:
On Fri, 2025-11-07 at 08:38 -0600, olcott wrote:
On 11/7/2025 8:35 AM, wij wrote:
On Fri, 2025-11-07 at 08:28 -0600, olcott wrote:
On 11/7/2025 8:12 AM, wij wrote:
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:Then its the wrong 'H'. Read the Halting Problem carefully. >>>>>>>>>>>
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:No, it is bounded.
No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its theI have no idea what you are saying here.
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is >>>>>>>>>>>>>>> nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being
really about D'.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'! >>>>>>>>>>>>>> In the updated version a finite string of ASCII characters that definesa C function that calls its own C interpreter.
a single function/program with a definite halting status. >>>>>>>>>>>>>
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
You haven’t shown that. H could easily save the state of the simulation,Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels ofThat only happens when you screw up the specified execution trace.
D simulations starting up --- and individually terminating. >>>>>>>>>>>>>
return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the >>>>>>>>>>>>> halting H.
D simulated by the executed H does not call any halting H. >>>>>>>>>>>
In HP proof, the counter-case D refers to the real DECIDER that reports the
result, not something else.
You think that D runs forever because it calls the non- >>>>>>>>>>>>> decider H. There can be no correct patterns in the diagonal case. >>>>>>>>>>>>If this is your most fundamental belief it may seem
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer. >>>>>>>>>>>
Every fix to the detection logic gives rise to a new program that >>>>>>>>>>>>> doesn’t match it.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts), >>>>>>>>>>> D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D. >>>>>>>>>>>
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your
head is harder than the stone (and the chick is thicker than steel).
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree. >>>>>>>>>
It might seem that way if you didn't understand
a word that I just said
You are false god. What you said is garbage.
and don't know anything
about programming in C.
No one here (except you) who need debugger to explain C 'semantic'. >>>>>>> And see the assembly dump as 'proof'. Wake up, idiot.
If I was incorrect then you could show what
the correct execution trace should be.
First of all, the correct halt decider does not exist.
Changing the subject is known as the strawman deception
it is what cheaters do when they have no actual rebuttal
and still want to be disagreeable.
I am only talking about D simulated by H.
I have no problem of "D simulated by (POO) H", except if you claim the HP proof
is refuted is a big problem.
As to the constantly changing POOH, many people have already explained to you.
So you accept that D simulated by H cannot possibly
reach its own simulated "return" statement?
Repeat:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
If the H(D) in D above is a halt decider, D() cannot return. (the last line, obvious)
As to "D simulated by H", that is Peter Olcott's Own Problem, not what
the HP concerns.
If you want to understand 'the simulating H', people already explained.
On 11/7/2025 2:05 AM, Mikko wrote:
On 2025-11-06 20:48:02 +0000, olcott said:
D simulated by H cannot possibly reach its own
simulated final halt state.
That is merely a defect in H and irrelevanto to the semantic and other
properties of D.
That's a stupid statement.
No, that would not be a proof. A proof is a seuence of sentences,
A proof is any damn thing that shows a conclusion
is necessarily true.
On 07/11/2025 14:04, olcott wrote:
No, that would not be a proof. A proof is a seuence of sentences,
A proof is any damn thing that shows a conclusion
is necessarily true.
Wellll.. that's subjective. That only requires that the appraiser and
prover agree on the truth of the conclusion.
Lunatic1: "I had my favourite sandwich today, ergo God exists"
Lunatic2: "Yes, yes he does."
Lunatic2 thinks for a moment
Lunatic2: "Why did you tell me about your sandwich?"
We're in comp.theory, we should use logistic and proof-theoretic
meanings of "proof".
--
Tristan Wibberley
The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.
On 2025-11-07 12:57:48 +0000, olcott said:
On 11/7/2025 2:05 AM, Mikko wrote:
On 2025-11-06 20:48:02 +0000, olcott said:
D simulated by H cannot possibly reach its own
simulated final halt state.
That is merely a defect in H and irrelevanto to the semantic and other
properties of D.
That's a stupid statement.
Stupid is better than false.
No, that would not be a proof. A proof is a seuence of sentences,
On 11/8/2025 3:43 AM, Tristan Wibberley wrote:^^
On 07/11/2025 14:04, olcott wrote:
A proof is any damn thing that shows a conclusion
is necessarily true.
Wellll.. that's subjective. That only requires that the appraiser and
prover agree on the truth of the conclusion.
I am talking about correct semantic logical entailment
On 2025-11-07 14:04:22 +0000, olcott said:
On 11/7/2025 2:26 AM, Mikko wrote:
On 2025-11-06 10:54:43 +0000, olcott said:
On 11/6/2025 2:55 AM, Mikko wrote:
On 2025-11-05 11:37:15 +0000, olcott said:
On 11/5/2025 4:53 AM, Mikko wrote:
On 2025-11-04 13:56:17 +0000, olcott said:
On 11/4/2025 4:10 AM, Mikko wrote:
On 2025-11-03 23:28:03 +0000, olcott said:
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your >>>>>>>>>>> perfirmance in the art of excution traces". You didn't ppint out >>>>>>>>>>> any error or incoherence in that sentence. Instead you said >>>>>>>>>>> "There is no mistake in the essence of above."
*Claude, ChatGPGT, Gemini and Grok all agree on this*
*links provided below*
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to *see whether that simulated*
*execution ever reaches a return statement* Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
That is irrelevant to anything in the quoted text.
You didn't even pay attention to the words the last paragraph.
Everything in the last paragraph, including the question, is
as ifrrelevant as the text before.
One should also note that you didn't identify any relevance.
It forms a proof that H(D) is correct to reject (D).
That you didn't see that proves that you are not
paying close enough attention.
If does not form a proof of anything.
The proof would be my reviewers actually knowing C
programming and being able to do their own execution
trace.
No, that would not be a proof. A proof is a seuence of sentences,
A proof is any damn thing that shows a conclusion
is necessarily true.
It is not a proof if you it doesn't show without a proof that it shows.
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
This does not define a behaviour. The knowledge whether H(D) returns and
what value it returns if it does or what it does instead if it does not
is needed in order to know the behavour.
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
This is not a well formed sentence of Common Language. The "and" on the
third line is between the noun "the knowledge" and the verb "knows" but it
is impossible to construct a sentence where both are valid in the initial position. COnsequently nothing is shown.
Mikko wrote:
No, that would not be a proof. A proof is a seuence of sentences,
On 08/11/2025 13:25, olcott wrote, validly demonstrating a portion of a conversation:
On 11/8/2025 3:43 AM, Tristan Wibberley wrote:^^
On 07/11/2025 14:04, olcott wrote:
A proof is any damn thing that shows a conclusion
is necessarily true.
Wellll.. that's subjective. That only requires that the appraiser and
prover agree on the truth of the conclusion.
I am talking about correct semantic logical entailment
In this message perhaps, but not in the previous.
It's conversationally nuts.
--
Tristan Wibberley
The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.
How can people that are interested in the
theory of computation not have programming skill?
On 08/11/2025 13:41, olcott wrote:
How can people that are interested in the
theory of computation not have programming skill?
Theory of computation is not a programming-level topic. It's a work-breakdown, specification and strategy-level topic.
--
Tristan Wibberley
The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.
How can one begin
to understand anything about the theory of
computation without having hands on programming
experience?
On 08/11/2025 15:18, olcott wrote:
How can one begin
to understand anything about the theory of
computation without having hands on programming
experience?
Think about the difference between synthesis and analysis.
--
Tristan Wibberley
The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,076 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 77:09:04 |
| Calls: | 13,805 |
| Files: | 186,990 |
| D/L today: |
5,237 files (1,702M bytes) |
| Messages: | 2,443,143 |