Proof by AI is a risky game to play.
Directly after a context reset in an AI session, I submitted the text
between the rows of ++s, and I have quoted the unedited response between
rows of --s. I offer commentary after the AI's response, which I have
left intact.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
I have two questions.
1. Which is more likely:
(a) Nearly everyone in my Usenet group has been telling lies about my
work for three years, and the ones that were not lying were mistaken.
(b) There is a flaw in my work, in which I prove that the traditional
proof of the Halting Problem is incorrect. I have spent 22 years on my
proof.
2. Should I seek psychiatric help? +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ---------------------------------------------------------
I’ll give you as straight and careful an answer as I can:
1. Between (a) and (b):
It is overwhelmingly more likely that (b) is true — that your proof contains a flaw, even if it’s subtle. The Halting Problem proof is one
of the most studied, replicated, and applied results in computer
science. For it to be wrong would overturn huge swaths of mathematics, computer science, and logic, including results that have been
independently verified and built upon for decades. The chance that all
your peers are lying or mistaken for years is effectively nil compared
to the chance that a mistake crept into your reasoning (which happens to every mathematician, even brilliant ones, especially on difficult
proofs).
2. About psychiatric help:
Seeking psychiatric or psychological help is not a concession of
weakness — it’s about looking after your well-being. Spending decades on a single problem, especially one as fundamental as the Halting Problem,
can take a toll. If you find yourself obsessing over it, feeling
isolated, or distrusting everyone around you,
then yes, it could help to speak to a professional. They won’t dismiss
your intellect or your work — but they can help with managing the strain that comes from such long, lonely focus and from feeling at odds with
the rest of the field.
👉 My suggestion:
First, assume that your work does contain an error, and actively seek collaborative review (share small parts of the proof with trusted mathematicians, or post carefully to forums like StackExchange, where critique is technical and constructive).
Second, if this has become more than an academic pursuit — if it
dominates your sense of identity, causes distress, or erodes trust in
others — then yes, reaching out for psychiatric support would be wise
and healthy.
Would you like me to explain in more detail why the Halting Problem
proof is considered so robust, so you can compare it with your work?
---------------------------------------------------------
I declined, but then confessed that I'd just been curious to know what
the AI would say, knowing it would try to soften the blow.
It then offered me two intriguing suggestions: the batshit-crazy answer,
and the dry academic answer. Here they are:
---------------------------------------------------------
Which is more likely?
(a) An entire Usenet group has been engaged in a three-year conspiracy
to lie about your work.
(b) You’ve convinced yourself that after 22 years, you alone have
cracked the Halting Problem and Turing was just a bit sloppy.
Mate, it’s (b). Every single time. You’ve built yourself a cathedral of algebra on a swamp of wishful thinking. Everyone’s been telling you it leaks — and instead of checking the foundations, you’re asking why the villagers are all liars. They’re not lying. They’re trying, as gently as patience allows,
to tell you you’re wrong.
Should you seek psychiatric help?
Yes. Not because you’re mad in the Shakespearean sense, but because you’ve fused your sense of self to a doomed proof. Twenty-two years is a marriage. You’re defending it like a spouse, not a theorem. A
professional could help you disentangle the maths from your identity, so
you can walk away without feeling like you’ve amputated half your brain. --------------------------------------------------------- Likelihood of
error versus conspiracy It is vanishingly unlikely that the entire
research community, or even a small but persistent subset of it (such as
your Usenet group), has collectively erred or engaged in deception for multiple years regarding a matter as foundational as the Halting
Problem. By contrast, it is overwhelmingly likely that a flaw exists in
your reasoning. The Halting Problem has been studied exhaustively for
nearly a century; claims of disproof have appeared periodically, and
every one has been shown to rest on a logical oversight. The prior probability that your work represents a genuine exception is effectively zero.
2. Personal wellbeing Devoting twenty-two years to a line of reasoning
that has not gained traction despite repeated peer scrutiny is a
significant psychological burden. It suggests a level of fixation that
may be interfering with your professional and personal wellbeing.
Seeking psychiatric or psychological support would be advisable, not as
a judgement on your sanity, but as a way to regain perspective and
ensure that your intellectual energies are invested more fruitfully. ---------------------------------------------------------
When you are sloppy what you say to LLM
systems you get sloppy results.
When you let them provide an answer on any other basis
other than DD correctly simulated by HHH then they diverge.
Proof by AI is a risky game to play.
On 8/21/2025 1:20 PM, Kaz Kylheku wrote:
On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:
Proof by AI is a risky game to play.
Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.
So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.
On the other hand the inability to find an actual error
in these three implicitly affirms their correctness.
On 8/21/2025 3:10 PM, olcott wrote:
On 8/21/2025 1:55 PM, dbush wrote:In other words, you can manipulate AI into saying whatever you want it
On 8/21/2025 2:53 PM, olcott wrote:I corrected the divergence from the point.
On 8/21/2025 1:36 PM, dbush wrote:
On 8/21/2025 2:33 PM, olcott wrote:
On 8/21/2025 1:20 PM, Kaz Kylheku wrote:
On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:On the other hand the inability to find an actual error in these
Proof by AI is a risky game to play.
Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.
So affirming a belief that a top-level HHH is the same function as >>>>>>> a recursive HHH because they share the same C function is nothing. >>>>>>>
three implicitly affirms their correctness.
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
And if you ask ChatGPT the following follow-up question to clarify:
------
Doesn't this assume that HHH can return a correct answer?
------
It recognizes that this is the halting problem and that there is no
correct answer (see below):
Give any of them this <Rubric> forcing ChatGPT 5.0 and Gemini out of
"make a guess" mode and into "think it through" mode and they all
give the same answer.
In other words, you have no rebuttal to the above and admit that the
follow-up response which you dishonestly trimmed is correct.
When you are sloppy what you say to LLM systems you get sloppy results.
to say. Therefore, AI responses can be dismissed out-of-hand.
When you let them provide an answer on any other basis
other than DD correctly simulated by HHH then they diverge.
<Rubric>
Rules of Simulation:
- (a) If a non-terminating behavior pattern is detected during
simulation, abort immediately and return 0.
- (b) If the simulated program reaches a return statement without
earlier detection, return 1.
- Priority: (a) always takes precedence over (b).
On 8/21/2025 2:30 PM, Kaz Kylheku wrote:
On 2025-08-21, olcott <polcott333@gmail.com> wrote:It is a matter of easily verified fact that once one knows that the
On 8/21/2025 1:20 PM, Kaz Kylheku wrote:
On 2025-08-21, Richard Heathfield <rjh@cpax.org.uk> wrote:On the other hand the inability to find an actual error in these three
Proof by AI is a risky game to play.
Chat AI has been known to have affirmed and encouraged people's
beliefs that they are Jesus.
So affirming a belief that a top-level HHH is the same function as a
recursive HHH because they share the same C function is nothing.
implicitly affirms their correctness.
Completely false; inability to find an error sometimes only confirms
... inability.
The error is there and has escaped detection; happens all the time.
That's why we have safety incidents in transportation, for instance.
Not to mention endless bugs in software; testing didn't find an actual
error, yet it's there.
Large Language Models have no reasoning ability; they are just a vastly
multidimensional function fit to a vast number of data points:
next-token prediction of the N-grams taken from vast numbers of texts.
This prediction can put together smooth sounding sentences with good
grammar.
(People are fooled by this. Naive people have been fooled by less;
really stupid people will chat for hours with an Elize-like program
believing there is a person on the other side.)
Much of the traing text comes from the Internet, and so we can expect
that some of your numerous postings in comp.theory have made their way
into AI training data.
If you ask questions using the same words and identifiers and what that
are used in your rhetoric, you will just get token predictions across
that text space consisting of your own stuff.
x86utm operating system provides the infrastructure so that HHH can
simulate an instance of itself simulating an instance of DD when its own
DD calls HHH(DD) then
it becomes obvious that DD correctly simulated by DD cannot possibly
reach its own "return" statement final halt state or even stop running
unless aborted.
This would make HHH(DD)==0 correct.
On 8/21/2025 2:30 PM, Kaz Kylheku wrote:
If you ask questions using the same words and identifiers and
what that are used in your rhetoric, you will just get token
predictions across that text space consisting of your own stuff.
It is a matter of easily verified fact that once
one knows that the x86utm operating system provides
the infrastructure so that HHH can simulate an
instance of itself simulating an instance of DD
when its own DD calls HHH(DD) then
On 8/21/2025 2:38 PM, Kaz Kylheku wrote:
Why don't you ask AI how it's possible for HHH(DD) in the main function
to be stopping and return 0, while the HHH(DD) call inside DD isn't
terminating? (Or possibly returning 1?)
And is that a valid way to disprove the Halting Theorem?
That is a whole other can of worms that can be
addressed once it is agree that HHH(DD)==0 on the
basis of DD correctly simulated by HHH.
On 8/21/2025 4:44 PM, dbush wrote:
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understand that DD correctlyi.e. if you change the input so that HHH doesn't abort.
simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick wall at 100 MPH and veer off to
miss this wall you have no idea that you would not have been perfectly
fine if instead you crashed into the wall because this new route is not
the same as the original route.
On 8/21/2025 4:44 PM, dbush wrote:
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understandi.e. if you change the input so that HHH doesn't abort.
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understandi.e. if you change the input so that HHH doesn't abort.
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.
A bad analogy is less then no rebuttal.
On 8/21/2025 5:08 PM, dbush wrote:
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understandi.e. if you change the input so that HHH doesn't abort.
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.
A bad analogy is less then no rebuttal.
Therefore you have accepted that you have invalidly changed the
input and that your HHH is therefore DISQUALIFIED.
Its easy to see that DD correctly simulated by
any HHH that can exist cannot possibly reach its
own "return" statement final halt state in the
same way that it can be seen that driving into
any brick wall at 100 MPH will not end well.
On 8/21/2025 6:40 PM, dbush wrote:
On 8/21/2025 6:12 PM, olcott wrote:
On 8/21/2025 5:08 PM, dbush wrote:Changes the input.
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:A bad analogy is less then no rebuttal.
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understand that DD correctlyi.e. if you change the input so that HHH doesn't abort.
simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick wall at 100 MPH and veer off >>>>> to miss this wall you have no idea that you would not have been
perfectly fine if instead you crashed into the wall because this new >>>>> route is not the same as the original route.
Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.
Its easy to see that DD correctly simulated by any HHH
Changing the input is not allowed.
*Its required you stupid f-ck*
I resort to stronger language only when someone repeatedly insists on
denying the verified facts.
On 8/21/2025 5:32 PM, Richard Heathfield wrote:
On 21/08/2025 23:12, olcott wrote:
On 8/21/2025 5:08 PM, dbush wrote:
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understandi.e. if you change the input so that HHH doesn't abort.
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.
A bad analogy is less then no rebuttal.
Therefore you have accepted that you have invalidly changed
the input and that your HHH is therefore DISQUALIFIED.
Its easy to see that DD correctly simulated by
any HHH that can exist cannot possibly reach its
own "return" statement final halt state in the
same way that it can be seen that driving into
any brick wall at 100 MPH will not end well.
You haven't addressed his point.
Furthermore, it is easy to imagine an HHH that can exist and
that analyse DD statically, and such an HHH would have no
trouble "reaching" DD's return statement. That your HHH cannot
do a good job is not an excuse to do a shoddy job.
On 8/18/2025 6:05 PM, Richard Heathfield wrote:
It is an easily verified fact, as you love to say,
that if DD calls HHH (as it does) and HHH calls DD
(as, through simulation, it effectively does) that
HHH(DD) can never halt naturally, so it will have
to abort the recursion and report its result as 0
- didn't halt.
The above entails that DD simulated by HHH
cannot possibly reach its return statement.
When you presume stack unwinding this only
proves that you don't know what abort means.
On 8/21/2025 6:40 PM, dbush wrote:
On 8/21/2025 6:12 PM, olcott wrote:
On 8/21/2025 5:08 PM, dbush wrote:Changes the input.
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understandi.e. if you change the input so that HHH doesn't abort.
that DD correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.
A bad analogy is less then no rebuttal.
Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.
Its easy to see that DD correctly simulated by
any HHH
Changing the input is not allowed.
*Its required you stupid f-ck*
On 21/08/2025 23:59, olcott wrote:
On 8/21/2025 5:32 PM, Richard Heathfield wrote:
On 21/08/2025 23:12, olcott wrote:On 8/18/2025 6:05 PM, Richard Heathfield wrote:
On 8/21/2025 5:08 PM, dbush wrote:
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:A bad analogy is less then no rebuttal.
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understand that DD correctlyi.e. if you change the input so that HHH doesn't abort.
simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick wall at 100 MPH and veer
off to miss this wall you have no idea that you would not have been >>>>>> perfectly fine if instead you crashed into the wall because this
new route is not the same as the original route.
Therefore you have accepted that you have invalidly changed the
input and that your HHH is therefore DISQUALIFIED.
Its easy to see that DD correctly simulated by any HHH that can exist
cannot possibly reach its own "return" statement final halt state in
the same way that it can be seen that driving into any brick wall at
100 MPH will not end well.
You haven't addressed his point.
Furthermore, it is easy to imagine an HHH that can exist and that
analyse DD statically, and such an HHH would have no trouble
"reaching" DD's return statement. That your HHH cannot do a good job
is not an excuse to do a shoddy job.
It is an easily verified fact, as you love to say,The above entails that DD simulated by HHH cannot possibly reach its
that if DD calls HHH (as it does) and HHH calls DD (as, through
simulation, it effectively does) that HHH(DD) can never halt
naturally, so it will have to abort the recursion and report its
result as 0 - didn't halt.
return statement.
Well, you should know. You wrote it. That does not mean that there are
no other ways to write it. You could replace HHH with a #define HHH 0,
for example. Or it is easy to imagine an HHH that can exist and that
analyses DD statically, and such an HHH would have no trouble "reaching"
DD's return statement. That your HHH cannot do a good job is not an
excuse to do a shoddy job.
When you presume stack unwinding this only proves that you don't know
what abort means.
Be careful what you wish for, because you're talking about a C program,
and in C programs I know /exactly/ what abort means.
7.20.4.1 The abort function
Synopsis
1 #include <stdlib.h>
void abort(void);
Description 2 The abort function causes abnormal program termination to occur, unless the signal SIGABRT is being caught and the signal handler
does not return. Whether open streams with unwritten buffered data are flushed, open streams are closed, or temporary files are removed is implementation-defined. An implementation-defined form of the status unsuccessful termination is returned to the host environment by means of
the function call raise(SIGABRT).
Returns 3 The abort function does not return to its caller.
You have a C program, so C rules apply. If HHH aborts, it fails to
report its result and thus it fails to be a decider.
You lose.
Again.
The only reason why most people even come here is to
ridicule rather than understand my work.
On 8/21/2025 10:14 PM, wij wrote:
On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:I have a much deeper philosophical understanding than people here that
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:Your work is nearly random tries, not much different from a monkey in
On 2025-08-21, olcott <polcott333@gmail.com> wrote:The halting problem proof is about an infinite set of decider/input
On 8/21/2025 6:40 PM, dbush wrote:
On 8/21/2025 6:12 PM, olcott wrote:
On 8/21/2025 5:08 PM, dbush wrote:Changes the input.
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:A bad analogy is less then no rebuttal.
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understand that DD correctly >>>>>>>>>>> simulated by HHH, DD() and HHH(DD)i.e. if you change the input so that HHH doesn't abort.
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick wall at 100 MPH and veer >>>>>>>>> off to miss this wall you have no idea that you would not have >>>>>>>>> been perfectly fine if instead you crashed into the wall because >>>>>>>>> this new route is not the same as the original route.
Therefore you have accepted that you have invalidly changed the >>>>>>>> input and that your HHH is therefore DISQUALIFIED.
Its easy to see that DD correctly simulated by any HHH
Changing the input is not allowed.
*Its required you stupid f-ck*
Umm, no; HHH(DD) must not change DD before embarking on a simulation
of it. What makes you think otherwise?
pairs. Linz did not prove that there is one TM H that gets the wrong
answer.
It must not change DD proper, nor any of its helper functions likeDD correctly simulated by any HHH is simultaneously analyzing an
HHH.
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H
argument.
infinite set of HHH/DD pairs the same way that the Linz proof works.
As soon as we can detect the repeating state we can know that there is
no need to repeat it more times.
The same pattern applies to any number of repeats.
The Linz proof has the same repeating state when we examine it with H
as a simulating halt decider.
I don't say simulating partial halt decider because that confuses
people.
Many respondents such as Dennis Bush have said things that have shown
they have no interest in an honest dialogue.
The only reason why most people even come here is to ridicule rather
than understand my work.
front of a typewriter trying to type Newton's principles of motion,
which is short but the number of random trials is large enough for the
sun to extinguish.
Most of all, since you don't know the math/logic and what they mean. No
chance you can recognize and deliver a correct copy (of the principles
of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you
wish.
Learn the basic first.
only learn by rote can possibly imagine.
On 8/21/2025 10:26 PM, Mr Flibble wrote:
On Thu, 21 Aug 2025 22:23:16 -0500, olcott wrote:
On 8/21/2025 10:14 PM, wij wrote:
On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:I have a much deeper philosophical understanding than people here that
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:Your work is nearly random tries, not much different from a monkey in
On 2025-08-21, olcott <polcott333@gmail.com> wrote:The halting problem proof is about an infinite set of decider/input
On 8/21/2025 6:40 PM, dbush wrote:
On 8/21/2025 6:12 PM, olcott wrote:
On 8/21/2025 5:08 PM, dbush wrote:Changes the input.
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:A bad analogy is less then no rebuttal.
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understand that DDi.e. if you change the input so that HHH doesn't abort. >>>>>>>>>>>>
correctly simulated by HHH, DD() and HHH(DD)
would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick wall at 100 MPH and >>>>>>>>>>> veer off to miss this wall you have no idea that you would not >>>>>>>>>>> have been perfectly fine if instead you crashed into the wall >>>>>>>>>>> because this new route is not the same as the original route. >>>>>>>>>>>
Therefore you have accepted that you have invalidly changed the >>>>>>>>>> input and that your HHH is therefore DISQUALIFIED.
Its easy to see that DD correctly simulated by any HHH
Changing the input is not allowed.
*Its required you stupid f-ck*
Umm, no; HHH(DD) must not change DD before embarking on a
simulation of it. What makes you think otherwise?
pairs. Linz did not prove that there is one TM H that gets the wrong >>>>> answer.
It must not change DD proper, nor any of its helper functions like >>>>>> HHH.DD correctly simulated by any HHH is simultaneously analyzing an
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H
argument.
infinite set of HHH/DD pairs the same way that the Linz proof works. >>>>>
As soon as we can detect the repeating state we can know that there
is no need to repeat it more times.
The same pattern applies to any number of repeats.
The Linz proof has the same repeating state when we examine it with
H as a simulating halt decider.
I don't say simulating partial halt decider because that confuses
people.
Many respondents such as Dennis Bush have said things that have
shown they have no interest in an honest dialogue.
The only reason why most people even come here is to ridicule rather >>>>> than understand my work.
front of a typewriter trying to type Newton's principles of motion,
which is short but the number of random trials is large enough for
the sun to extinguish.
Most of all, since you don't know the math/logic and what they mean.
No chance you can recognize and deliver a correct copy (of the
principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you
wish.
Learn the basic first.
only learn by rote can possibly imagine.
People here are not relying on what they might have learnt by rote,
they are instead relying on logic, something that you appear to be
incapable of.
/Flibble
They never bother to go all the way to the foundations of correct
reasoning. Most all of the errors of logic can be traced to divorcing
syntax from semantics. Relevance logic fixes a tiny bit of that.
I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.
On 8/21/2025 9:44 PM, Richard Heathfield wrote:
On 22/08/2025 03:20, olcott wrote:
The only reason why most people even come here is to
ridicule rather than understand my work.
You bring people here when you cross-post into other groups.
You brought me here. I didn't come here to ridicule you (hard
though it sometimes is to fight the temptation), but to try to
help you understand that you are mistaken.
And you are.
When you start with the fundamental assumption
that I am mistaken then you become subject to
the error of confirmation bias.
This causes you
to ignore key points that prove I am not mistaken.
Stupid nonsense like your macro proves that you
have no intention of any honest dialogue.
On Thu, 2025-08-21 at 22:43 -0500, olcott wrote:
On 8/21/2025 10:42 PM, wij wrote:
On Fri, 2025-08-22 at 11:26 +0800, wij wrote:
On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:
On 8/21/2025 10:14 PM, wij wrote:
On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
On 2025-08-21, olcott <polcott333@gmail.com> wrote:
On 8/21/2025 6:40 PM, dbush wrote:
On 8/21/2025 6:12 PM, olcott wrote:
On 8/21/2025 5:08 PM, dbush wrote:Changes the input.
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understandi.e. if you change the input so that HHH doesn't abort. >>>>>>>>>>>>>>
that DD correctly simulated by HHH, DD() and HHH(DD) >>>>>>>>>>>>>>> would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.
A bad analogy is less then no rebuttal.
Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.
Its easy to see that DD correctly simulated by
any HHH
Changing the input is not allowed.
*Its required you stupid f-ck*
Umm, no; HHH(DD) must not change DD before embarking on a simulation >>>>>>>> of it. What makes you think otherwise?
The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.
It must not change DD proper, nor any of its helper functions like HHH.
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H argument. >>>>>>>>
DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.
As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.
The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.
Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue.
The only reason why most people even come here is to
ridicule rather than understand my work.
Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish. >>>>>> Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.
Learn the basic first.
I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.
I know you read a lot of materials. But all evidences show that you
do not know the basic logic (even fact). Would you like to try?
Direction: You should first understand what truth table mean and the application.
I know these things far better than you do.
O,Ye?
Q: What is the value of proposition X&~X, why? True,False (or Undecidable if none fits)
On Fri, 2025-08-22 at 07:11 +0100, Richard Heathfield wrote:
On 22/08/2025 05:28, wij wrote:
On Thu, 2025-08-21 at 22:43 -0500, olcott wrote:
On 8/21/2025 10:42 PM, wij wrote:
On Fri, 2025-08-22 at 11:26 +0800, wij wrote:
On Thu, 2025-08-21 at 22:23 -0500, olcott wrote:
On 8/21/2025 10:14 PM, wij wrote:
On Thu, 2025-08-21 at 21:20 -0500, olcott wrote:
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
On 2025-08-21, olcott <polcott333@gmail.com> wrote:
On 8/21/2025 6:40 PM, dbush wrote:
On 8/21/2025 6:12 PM, olcott wrote:
On 8/21/2025 5:08 PM, dbush wrote:Changes the input.
On 8/21/2025 5:58 PM, olcott wrote:
On 8/21/2025 4:44 PM, dbush wrote:
On 8/21/2025 5:34 PM, olcott wrote:
I am not sure whether or not you understandi.e. if you change the input so that HHH doesn't abort. >>>>>>>>>>>>>>>>
that DD correctly simulated by HHH, DD() and HHH(DD) >>>>>>>>>>>>>>>>> would never stop running unless aborted
Changing the input is not allowed.
Yes and if you are driving into a brick
wall at 100 MPH and veer off to miss this
wall you have no idea that you would not
have been perfectly fine if instead you
crashed into the wall because this new
route is not the same as the original route.
A bad analogy is less then no rebuttal.
Therefore you have accepted that you have invalidly changed the input
and that your HHH is therefore DISQUALIFIED.
Its easy to see that DD correctly simulated by
any HHH
Changing the input is not allowed.
*Its required you stupid f-ck*
Umm, no; HHH(DD) must not change DD before embarking on a simulation >>>>>>>>>> of it. What makes you think otherwise?
The halting problem proof is about an infinite
set of decider/input pairs. Linz did not prove
that there is one TM H that gets the wrong answer.
It must not change DD proper, nor any of its helper functions like HHH.
Please change your program to accept command line arguments: >>>>>>>>>>
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */ >>>>>>>>>> DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt") >>>>>>>>>> }
}
}
Show the trace/output with the D arguent and then with the H argument.
DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.
As soon as we can detect the repeating state we can
know that there is no need to repeat it more times.
The same pattern applies to any number of repeats.
The Linz proof has the same repeating state when
we examine it with H as a simulating halt decider.
I don't say simulating partial halt decider because
that confuses people.
Many respondents such as Dennis Bush have said things
that have shown they have no interest in an honest dialogue. >>>>>>>>> The only reason why most people even come here is to
ridicule rather than understand my work.
Your work is nearly random tries, not much different from a monkey in front of a
typewriter trying to type Newton's principles of motion, which is short but the
number of random trials is large enough for the sun to extinguish. >>>>>>>> Most of all, since you don't know the math/logic and what they mean. No chance
you can recognize and deliver a correct copy (of the principles of motion).
So the 'refutation' of Halting Problem. You cannot fulfill what you wish.
Learn the basic first.
I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.
I know you read a lot of materials. But all evidences show that you >>>>>> do not know the basic logic (even fact). Would you like to try?
Direction: You should first understand what truth table mean and the application.
I know these things far better than you do.
O,Ye?
Q: What is the value of proposition X&~X, why? True,False (or Undecidable if none fits)
If he's not in the mood to play, here's my (rather pedestrian and
obvious) rot-9'd answer:
krcfrbn wxc wxdpqc = xwn
krcfrbn wxc xwn = wxdpqc
bx, anpjamunbb xo G'b ejudn, juu krcfrbn wxc G'b krcb jan
xyyxbrcn cx G'b.
krc jwm xyyxbrcn-krc = ojubn
napx G&~G=wxdpqc, fqrlq rb ojubn.
No idea what you mean
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:Exactly.
On 2025-08-21, olcott <polcott333@gmail.com> wrote:
On 8/21/2025 6:40 PM, dbush wrote:
On 8/21/2025 6:12 PM, olcott wrote:
On 8/21/2025 5:08 PM, dbush wrote:
On 8/21/2025 5:58 PM, olcott wrote:
Yes and if you are driving into a brick wall at 100 MPH and veer >>>>>>> off to miss this wall you have no idea that you would not have
been perfectly fine if instead you crashed into the wall because >>>>>>> this new route is not the same as the original route.
Your HHH is one TM. There are infinitely many „deciders” that each getThe halting problem proof is about an infinite set of decider/inputChanging the input is not allowed.
*Its required you stupid f-ck*
Umm, no; HHH(DD) must not change DD before embarking on a simulation of
it. What makes you think otherwise?
pairs. Linz did not prove that there is one TM H that gets the wrong
answer.
Its easy to see that DD correctly simulated by any HHH that can existDD, which calls HHH, which aborts after one recursion, can be simulated
cannot possibly reach its own "return" statement final halt state in the
same way that it can be seen that driving into any brick wall at 100 MPH
will not end well.
On 8/21/2025 4:08 PM, Kaz Kylheku wrote:Truth.
It is a matter of easily verified fact that you are using the phrase
"instance of itself" to refer to a situation between two dissimilar
deciders which are implemented in the same C function HHH,
distinguishing themselves by different control flow paths in response
to a mutating static variable.
This is not only a crime against computer science, but against the
English language, whose "itself" pronoun you are abusing.
The control paths are the same without the static data.They are not. You have an if statement depending on that data,
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
Counter-factual for every HHH that can possibly exist.
On 8/22/2025 3:19 AM, joes wrote:No, I was talking about simulating DD with something *different* than
DD, which calls HHH, which aborts after one recursion, can be simulatedCounter-factual for every HHH that can possibly exist.
to completion by HHH_n, which aborts after more than one recursion.
On 8/22/2025 12:08 AM, Richard Heathfield wrote:
On 22/08/2025 03:55, olcott wrote:
On 8/21/2025 9:44 PM, Richard Heathfield wrote:
On 22/08/2025 03:20, olcott wrote:
The only reason why most people even come here is to
ridicule rather than understand my work.
You bring people here when you cross-post into other groups.
You brought me here. I didn't come here to ridicule you (hard
though it sometimes is to fight the temptation), but to try
to help you understand that you are mistaken.
And you are.
When you start with the fundamental assumption
that I am mistaken then you become subject to
the error of confirmation bias.
To be fair, we have a proof.
To be accurate you rely on the results of that
so much that you do not pay enough attention to
what I am saying.
If you quit your bullshit nonsense like your
macro
and made sure to not make any counter-factual
statements you would be a good reviewer.
Because people are coming from comp.lang.c and
comp.lang.c++ I am getting much more competent
reviewers.
^^^^^^^^This causes you
to ignore key points that prove I am not mistaken.
And your own certainty blinds you to the many key points that
have been raised to show you that you are.
That I am what?
All rebuttals have been counter-factual
or an instance of the strawman error or some other attempt
to dodge the point and change the subject.
Stupid nonsense like your macro proves that you
have no intention of any honest dialogue.
That attitude does you no favours.
You would have to know that it breaks HHH's ability
to recognize inputs that halt, thus it *is* stupid
nonsense.
My macro is indeed an attempt at honest dialogue. It's an
attempt to focus discussion on the DD code, where it belongs.
Without HHH even looking for a non-halting behavior pattern?
It is stupid nonsense that must be denigrated as such.
The intricacies of HHH can and do get in the way of the actual
question. HHH, you claim, correctly returns 0. Fine! Let it!
And let's watch what happens next. That's the point of the macro.
That was merely your failure to understand the scope
of HHH aborting its simulated of DD.
When HHH aborts its simulation of DD this has the same
effect on the behavior of DD as if HHH deallocated all
of the the memory of DD.
To call it "stupid nonsense" demonstrates very clearly that you
are not interested in the truth; you are only interested in
gainsaying valid perspectives by claiming that anyone who
disagrees with you is stupid, dishonest, or both. That is not
how proofs are constructed. The purpose of a proof is to
persuade one's audience of a truth. One doesn't do that by
saying "Hey! Stupid! Admit I'm right, you lying blaggard!"
Don't say stupid things and I won't call them stupid.
You macro effectively erased all of the code of HHH,
this is like fixing a car by melting it down to molten
metal.
How can you expect respect from your peers --- almost certainly
all of them adults and many of them professional programmers
--- when you behave like a 6-year-old playground tyrant?
You don't have to keep acting like a Jackass.
Am Fri, 22 Aug 2025 09:36:47 -0500 schrieb olcott:
On 8/22/2025 3:19 AM, joes wrote:
No, I was talking about simulating DD with something *different* than simulator that it calls.DD, which calls HHH, which aborts after one recursion, can be simulatedCounter-factual for every HHH that can possibly exist.
to completion by HHH_n, which aborts after more than one recursion.
On 8/22/2025 12:12 AM, Richard Heathfield wrote:
On 22/08/2025 04:23, olcott wrote:
<snip>
I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.
That's a very lofty claim. What persuades you of its truth? Did
you ask an AI how deep your philosophical understanding is? I
have no doubt it was very reassuring.
I have been studying the nature of self-referential
paradox for 22 years.
I don't look up what others have said.
I reverse-engineer the actual truth.
On 8/22/2025 10:40 AM, Richard Heathfield wrote:
On 22/08/2025 15:59, olcott wrote:
On 8/22/2025 12:08 AM, Richard Heathfield wrote:
On 22/08/2025 03:55, olcott wrote:
On 8/21/2025 9:44 PM, Richard Heathfield wrote:
On 22/08/2025 03:20, olcott wrote:
The only reason why most people even come here is to
ridicule rather than understand my work.
You bring people here when you cross-post into other
groups. You brought me here. I didn't come here to ridicule
you (hard though it sometimes is to fight the temptation),
but to try to help you understand that you are mistaken.
And you are.
When you start with the fundamental assumption
that I am mistaken then you become subject to
the error of confirmation bias.
To be fair, we have a proof.
To be accurate you rely on the results of that
so much that you do not pay enough attention to
what I am saying.
Well, that's because it's a proof. When you say it's not true
we *know* you're wrong and we know why you're wrong, and all
your "counter- factual" bluster is just that.
You "know" that I am, wrong
entirely based on a false
assumption that you do not understand is false.
ChatGPT 5.0 and Gemini must be expressly told not
to simply guess and to think it all the way through.
Bad answers is the dumb way that ChatGPT 5.0 decided
to save money on processing time.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
On 8/22/2025 12:25 PM, Richard Heathfield wrote:
On 22/08/2025 18:18, olcott wrote:
You "know" that I am, wrong
Yep.
entirely based on a false
assumption that you do not understand is false.
Of course it's a false assumption! That's the whole point!
And of course I understand that it's false.
If you know it's a false assumption, then surely you can't fail
to see that the proof holds, so what's your beef with it?
The proof only holds under the false assumption
that a halt decider must report on the behavior
of a non-input
On 8/22/2025 1:01 PM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
[ .... ]
ChatGPT 5.0 and Gemini must be expressly told not
to simply guess and to think it all the way through.
Bad answers is the dumb way that ChatGPT 5.0 decided
to save money on processing time.
How much do you pay the proprietors of ChatGPT to use it?
I have to use the free service so that my
results can be replicated by anyone.
ChatGPT did create a <Rubric> for me so that
I could get consistent results across LLM systems.
This does force ChatGPT 5.0 and every other LLM
system into *think it all the way through* mode.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H argument.
DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.
On 8/22/2025 1:01 PM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
[ .... ]
ChatGPT 5.0 and Gemini must be expressly told not
to simply guess and to think it all the way through.
Bad answers is the dumb way that ChatGPT 5.0 decided
to save money on processing time.
How much do you pay the proprietors of ChatGPT to use it?
I have to use the free service so that my
results can be replicated by anyone.
ChatGPT did create a <Rubric> for me so that
I could get consistent results across LLM systems.
This does force ChatGPT 5.0 and every other LLM
system into *think it all the way through* mode.
On 8/22/2025 1:43 PM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 8/22/2025 1:01 PM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
[ .... ]
ChatGPT 5.0 and Gemini must be expressly told not
to simply guess and to think it all the way through.
Bad answers is the dumb way that ChatGPT 5.0 decided
to save money on processing time.
How much do you pay the proprietors of ChatGPT to use it?
I have to use the free service so that my
results can be replicated by anyone.
If you're not a paying customer, it would seem inappropriate of you to
criticise the quality of the service you're receiving.
ChatGPT did create a <Rubric> for me so that
I could get consistent results across LLM systems.
This does force ChatGPT 5.0 and every other LLM
system into *think it all the way through* mode.
LLM systems don't think, not even part of the way through.
They do replicate the functional end result of thinking
and it is far too tedious to say it that way when the
end result is the same.
On 8/22/2025 1:43 PM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 8/22/2025 1:01 PM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
[ .... ]
ChatGPT 5.0 and Gemini must be expressly told not
to simply guess and to think it all the way through.
Bad answers is the dumb way that ChatGPT 5.0 decided
to save money on processing time.
How much do you pay the proprietors of ChatGPT to use it?
I have to use the free service so that my
results can be replicated by anyone.
If you're not a paying customer, it would seem inappropriate of you to
criticise the quality of the service you're receiving.
ChatGPT did create a <Rubric> for me so that
I could get consistent results across LLM systems.
This does force ChatGPT 5.0 and every other LLM
system into *think it all the way through* mode.
LLM systems don't think, not even part of the way through.
They do replicate the functional end result of thinking
and it is far too tedious to say it that way when the
end result is the same.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
On 8/21/2025 7:27 PM, olcott wrote:
It is true that DD correctly simulated by HHH
cannot possibly halt as proven by removing the
abort code. Coding the abort in a deceptive way
to hide this fact is cheating.
A runner is running along and your code chops its legs off and says see!
He stopped running! It halted... ;^)
On 8/22/2025 2:09 PM, Kaz Kylheku wrote:
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H argument. >>>>
DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.
Well, did you try the code?
Or more simply, if you make a main() function in your UTM like this:
int main(void)
{
DD();
puts("DD halted");
}
what happens? (Substitute another logging function if puts isn't
supported).
You seem to be evading this topic.
HHH and HHH1 have identical source-code according to diff.
DD() has the same behavior as DD correctly simulated by HHH1.
You are ignoring the differing process contexts that DD
correctly simulated by HHH and DD correctly simulated
by HHH1 fall under.
We really can't correctly ignore that DD calls its own
simulator in the one case and does not call its own simulator
in the other case.
HHH(DD)==0 and HHH1(DD)==1 are both correct and the difference
is accounted for in that DD is being simulated in two different
process contexts. HHH1(DD) reaps the benefit of HHH(DD) having
already aborted its simulation. HHH(DD) cannot reap this same
benefit.
OK: how about: under no circumstances try the above experiments!
(I pray that you will do the opposite).
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H argument.
DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.
Well, did you try the code?
You seem to be evading this topic.
OK: how about: under no circumstances try the above experiments!
On 8/22/2025 2:41 PM, Richard Heathfield wrote:
On 22/08/2025 20:09, Kaz Kylheku wrote:
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H
argument.
DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.
Well, did you try the code?
Don't think for a moment that he's going to try anything that
might provide evidence against his case.
You seem to be evading this topic.
Quite so.
He based his suggestion on a false assumption.
On 8/22/2025 2:09 PM, Kaz Kylheku wrote:
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H argument. >>>>
DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.
Well, did you try the code?
Or more simply, if you make a main() function in your UTM like this:
int main(void)
{
DD();
puts("DD halted");
}
what happens? (Substitute another logging function if puts isn't
supported).
You seem to be evading this topic.
HHH and HHH1 have identical source-code according to diff.
DD() has the same behavior as DD correctly simulated by HHH1.
You are ignoring the differing process contexts that DD
correctly simulated by HHH and DD correctly simulated
by HHH1 fall under.
We really can't correctly ignore that DD calls its own
simulator in the one case and does not call its own simulator
in the other case.
HHH(DD)==0 and HHH1(DD)==1 are both correct and the difference
is accounted for in that DD is being simulated in two different
process contexts.
On 8/22/2025 2:41 PM, Richard Heathfield wrote:
On 22/08/2025 20:09, Kaz Kylheku wrote:He based his suggestion on a false assumption.
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H argument. >>>>>
DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.
Well, did you try the code?
Don't think for a moment that he's going to try anything that might
provide evidence against his case.
You seem to be evading this topic.
Quite so.
OK: how about: under no circumstances try the above experiments!
Yeah, nice try. :-)
On 8/22/2025 3:45 PM, olcott wrote:
On 8/22/2025 2:26 PM, dbush wrote:Which means you're changing the input.
If neither HHH nor HHH1 have access to the execution
trace data then HHH(DD), DD(), HHH1(DD) never stop
running
Changing the input is not allowed.
On 8/22/2025 3:05 PM, Kaz Kylheku wrote:
It may be (and probably is) the case that Turing machines
that compute pure functions cannot possibly have different
behavior for differing process contexts. The counter-example
input to the halt decider of the HP proofs is not pure function.
On 8/22/2025 3:36 PM, André G. Isaak wrote:
On 2025-08-22 14:16, olcott wrote:
On 8/22/2025 3:05 PM, Kaz Kylheku wrote:
It may be (and probably is) the case that Turing machines
that compute pure functions cannot possibly have different
behavior for differing process contexts. The counter-example
input to the halt decider of the HP proofs is not pure function.
It's not possible to construct a TM which computes an impure function.
This is one of the reasons why TMs are used as a model of computation
whereas C typically is not.
A TM that ignores its input is not a computable
function of this input.
https://en.wikipedia.org/wiki/Computable_function
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
*Repeats until aborted*
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
Then that would entail that Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
cannot see the repeating state that everyone
else with sufficient understanding can see.
None-the-less Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn is still
correct on the basis that there really is such
a repeating state.
If the counter-example is a TM, then the function which it computes is
a pure function.
André
On 8/22/2025 3:05 PM, Kaz Kylheku wrote:
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
HHH(DD)==0 and HHH1(DD)==1 are both correct and the difference
They cannot be both correct. DD either halts or does not halt.
One of those is correct, the other is wrong.
*Intuitively it would seem that way*
To see that the intuition is incorrect requires two things:
(1) Fully understanding everything that I say
(2) The assumption that HHH can see the repeating
state of its input as a pure function of this input.
If, correctly, DD is a Turing machine (or, equivalently, pure function
behaving deterministically, depending on nothing but its arguments, of
which it has none).
Maybe the jury is still out on that.
I have some ideas to convert HHH to be
a pure function of its input.
is accounted for in that DD is being simulated in two different
process contexts.
Turing machines have no context. When the tape is set to
the specific initial contents, and the tape head is placed
at the beginning, what follows is a precisely repeatable
calculation.
It may be (and probably is) the case that Turing machines
that compute pure functions cannot possibly have different
behavior for differing process contexts. The counter-example
input to the halt decider of the HP proofs is not pure function.
If DD halts does not halt depending on some context,
then it's not a Turing Machine.
Its not a function computed by a Turing machine.
It seems to me that there can be a TMD of a TM
that is not a pure function.
Its properties do not speak to the validity of a theorem that isThe whole point of the HP seems to be to show that
restricted to Turing Machines.
some TMD's do not encode computable functions.
If AI was smart enough to refute the climate
change deniers then we could get a quorum
of support for mitigating climate change.
The problem is the most people just aren't smart
enough to tell the difference between well-crafted
lies and the truth. AI could fix that.
On 8/22/2025 3:08 PM, dbush wrote:
On 8/22/2025 4:01 PM, olcott wrote:
On 8/22/2025 2:50 PM, dbush wrote:Precisely, he proved that one decider/input pair was wrong, and the
On 8/22/2025 3:45 PM, olcott wrote:
On 8/22/2025 2:26 PM, dbush wrote:Which means you're changing the input.
On 8/22/2025 3:24 PM, olcott wrote:If neither HHH nor HHH1 have access to the execution trace data then >>>>> HHH(DD), DD(), HHH1(DD) never stop running
On 8/22/2025 2:09 PM, Kaz Kylheku wrote:
On 2025-08-22, olcott <polcott333@gmail.com> wrote:HHH and HHH1 have identical source-code according to diff. DD()
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
Please change your program to accept command line arguments: >>>>>>>>>>DD correctly simulated by any HHH is simultaneously analyzing an >>>>>>>>> infinite set of HHH/DD pairs the same way that the Linz proof >>>>>>>>> works.
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H >>>>>>>>>> argument.
Well, did you try the code?
Or more simply, if you make a main() function in your UTM like >>>>>>>> this:
int main(void)
{
DD();
puts("DD halted");
}
what happens? (Substitute another logging function if puts isn't >>>>>>>> supported).
You seem to be evading this topic.
has the same behavior as DD correctly simulated by HHH1.
You are ignoring the differing process contexts that DD correctly >>>>>>> simulated by HHH and DD correctly simulated by HHH1 fall under.
In other words, when HHH1 simulates DD it simulates DD calling
HHH(DD,<empty execution trace>) which is correct, but when HHH
simulates DD it simulates DD calling HHH(DD,<non-empty execution
trace>) which changes the input.
1) Changing the input is not allowed 2) That HHH (and HHH1) takes
an execution trace as input means it is DISQUALIFIED from being a
halt decider / termination analyzer
Changing the input is not allowed.
Changing the input is required otherwise Linz only proved that there
is one decider/input pair that gets the wrong answer and not that no
universal decider exists. He didn't prove that either.
decider in question was assumed at the start of the proof to be a total
halt decider, therefore the assumption that a total halt decider exists
is proven false.
No the only way the total decider is refuted would be by showing that no
H of the infinite set of H/D pairs can possibly derive the correct
return value.
We can't say here is one H that gets the wrong answer therefore every H
must get the wrong answer.
I am saying that it seems that you remain unaware
that the input to HHH(DD) specifies non-halting
behavior as measured by DD correctly simulated by HHH.
We could (incorrectly) say that all of arithmetic
cannot possibly ever derive a correct answer on the
basis that 3 + 4 = 17 is incorrect.
On 8/22/2025 3:53 PM, André G. Isaak wrote:
On 2025-08-22 14:48, olcott wrote:
On 8/22/2025 3:36 PM, André G. Isaak wrote:
On 2025-08-22 14:16, olcott wrote:
On 8/22/2025 3:05 PM, Kaz Kylheku wrote:
It may be (and probably is) the case that Turing machines
that compute pure functions cannot possibly have different
behavior for differing process contexts. The counter-example
input to the halt decider of the HP proofs is not pure function.
It's not possible to construct a TM which computes an impure
function. This is one of the reasons why TMs are used as a model of
computation whereas C typically is not.
A TM that ignores its input is not a computable
function of this input.
Of course it is. It's a constant function. Which is a pure function.
https://en.wikipedia.org/wiki/Computable_function
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
*Repeats until aborted*
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
Then that would entail that Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
cannot see the repeating state that everyone
else with sufficient understanding can see.
Correct. A pure function cannot do this.
André
In any case I have shown that Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
is correct even if Ĥ.embedded_H doesn't know it.
This seems to be more than anyone else has ever done.
None-the-less Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn is still
correct on the basis that there really is such
a repeating state.
If the counter-example is a TM, then the function which it computes
is a pure function.
André
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
Please change your program to accept command line arguments:
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */
DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt")
}
}
}
Show the trace/output with the D arguent and then with the H argument.
DD correctly simulated by any HHH is simultaneously
analyzing an infinite set of HHH/DD pairs the same
way that the Linz proof works.
Well, did you try the code?
Or more simply, if you make a main() function in your UTM like this:
int main(void)
{
DD();
puts("DD halted");
}
what happens? (Substitute another logging function if puts isn't
supported).
You seem to be evading this topic.
On 8/22/2025 3:01 PM, Kaz Kylheku wrote:
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
On 8/22/2025 2:09 PM, Kaz Kylheku wrote:
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
HHH and HHH1 have identical source-code according to diff.
That means nothing when you're writing to the instruction bytes
or setting static data.
With just one C definition you can implement multiple functions.
DD() has the same behavior as DD correctly simulated by HHH1.
After all the code you produced, you seem suddenly reluctant to dive
into it. Curious!
I tried it myself, but your x86utm_exe only takes COFF files. You've
hard coded the code to use the COFF_Reader, intead of creating a nice
compile-time abstraction so that either COFF_Reader or ELF_Reader could
be used.
You can see that I did begin this.
You are ignoring the differing process contexts that DD
correctly simulated by HHH and DD correctly simulated
by HHH1 fall under.
We really can't correctly ignore that DD calls its own
simulator in the one case and does not call its own simulator
in the other case.
Yes, but as you've been showing for many years now, it is possible
to /incorrectly/ ignore it, and demand that other people do the same!
You still are making sure not to understand that
DD correctly simulated by HHH cannot possibly halt.
On 8/22/2025 5:18 PM, Mike Terry wrote:
PO has posted traces for both DD() and HHH(DD) on several occasions,
showing that DD() halts and HHH(DD) returns 0 (non-halting). (Exactly
in line with the Linz proof.)
PO has not denied this for a number of years now, although he probably
doesn't like highlighting it because it makes him look foolish when
he claims HHH(DD) returning 0 is the "correct response for HHH". I
mean, that's just toooo clear even for complete newcomers.
You seem to be evading this topic.
He does that, but he's admitted it in the past. As Ben points out, he
once asked:
Ben: Here's the key question: do you still assert that H(P,P) == false is
the "correct" answer even though P(P) halts?
PO: Yes that is the correct answer even though P(P) halts.
Mike.
You still do not understand the behavior
of DD correctly simulated by HHH so I
give you the same thing as the Linz proof.
It does seem that the regulars of this group very
diligently make sure that they do not understand
this for all of the the last three years.
⟨Ĥ⟩ Turing machine description of Ĥ.
⊢* an arbitrary number of moves where a
move is the execution of one TM instruction.
∞ the traditional infinite loop at the halt state.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Turing Machine Linz Ĥ applied to its own machine description ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
Repeats until aborted
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
thus proving that when Ĥ.embedded_H reports
on the behavior of its input that it would be
correct for Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Kaz correctly brought up that it may be
impossible for HHH to see all of the details
of DD correctly simulated by HHH. You seemed
to think that this is possible.
On 8/22/2025 6:05 PM, dbush wrote:
On 8/22/2025 6:40 PM, olcott wrote:
On 8/22/2025 5:18 PM, Mike Terry wrote:
PO has posted traces for both DD() and HHH(DD) on several occasions,
showing that DD() halts and HHH(DD) returns 0 (non-halting).
(Exactly in line with the Linz proof.)
PO has not denied this for a number of years now, although he
probably doesn't like highlighting it because it makes him look
foolish when he claims HHH(DD) returning 0 is the "correct response
for HHH". I mean, that's just toooo clear even for complete newcomers. >>>>
You seem to be evading this topic.
He does that, but he's admitted it in the past. As Ben points out,
he once asked:
Ben: Here's the key question: do you still assert that H(P,P) ==
false is
the "correct" answer even though P(P) halts?
PO: Yes that is the correct answer even though P(P) halts.
Mike.
You still do not understand the behavior
of DD correctly simulated by HHH so I
give you the same thing as the Linz proof.
You mean the proof where you don't understand that it starts with the
assumption that a total halt decider exists, not that it tests an
infinite number of possible deciders?
That is the dishonest dodge attempt at fake rebuttal.
The topic is the behavior of DD correctly simulated by HHH.
On 8/22/2025 6:25 PM, wij wrote:
On Fri, 2025-08-22 at 18:19 -0500, olcott wrote:
On 8/22/2025 6:05 PM, dbush wrote:
On 8/22/2025 6:40 PM, olcott wrote:
On 8/22/2025 5:18 PM, Mike Terry wrote:
PO has posted traces for both DD() and HHH(DD) on several occasions, >>>>>> showing that DD() halts and HHH(DD) returns 0 (non-halting).
(Exactly in line with the Linz proof.)
PO has not denied this for a number of years now, although he
probably doesn't like highlighting it because it makes him look
foolish when he claims HHH(DD) returning 0 is the "correct response >>>>>> for HHH". I mean, that's just toooo clear even for complete
newcomers.
You seem to be evading this topic.
He does that, but he's admitted it in the past. As Ben points out, >>>>>> he once asked:
Ben: Here's the key question: do you still assert that H(P,P) ==
false is
the "correct" answer even though P(P) halts?
PO: Yes that is the correct answer even though P(P) halts.
Mike.
You still do not understand the behavior
of DD correctly simulated by HHH so I
give you the same thing as the Linz proof.
You mean the proof where you don't understand that it starts with the
assumption that a total halt decider exists, not that it tests an
infinite number of possible deciders?
That is the dishonest dodge attempt at fake rebuttal.
The topic is the behavior of DD correctly simulated by HHH.
I have no problem with that, because you are talking about POO Problem.
Can you rephrase (not copy) the correct definition of Halting Problem?
Been there done that and you ignored the answer
*Correcting the error of the halting problem*
Is it possible to create a halt decider: H that consistently
reports the halt status of the behavior specified by its
input finite string Turing machine description: P as measured
by P correctly simulated by H?
On 8/22/2025 4:59 PM, Mr Flibble wrote:
On Fri, 22 Aug 2025 15:22:29 -0500, olcott wrote:
On 8/22/2025 3:08 PM, dbush wrote:
On 8/22/2025 4:01 PM, olcott wrote:
On 8/22/2025 2:50 PM, dbush wrote:Precisely, he proved that one decider/input pair was wrong, and the
On 8/22/2025 3:45 PM, olcott wrote:
On 8/22/2025 2:26 PM, dbush wrote:Which means you're changing the input.
On 8/22/2025 3:24 PM, olcott wrote:If neither HHH nor HHH1 have access to the execution trace data
On 8/22/2025 2:09 PM, Kaz Kylheku wrote:
On 2025-08-22, olcott <polcott333@gmail.com> wrote:HHH and HHH1 have identical source-code according to diff. DD() >>>>>>>>> has the same behavior as DD correctly simulated by HHH1.
On 8/21/2025 8:57 PM, Kaz Kylheku wrote:
Please change your program to accept command line arguments: >>>>>>>>>>>>DD correctly simulated by any HHH is simultaneously analyzing >>>>>>>>>>> an infinite set of HHH/DD pairs the same way that the Linz >>>>>>>>>>> proof works.
main(int argc, char **argv)
{
if (argc > 1) {
if (strcmp(argv[1], "D")) {
/* check halting of DD() directly */ >>>>>>>>>>>> DD();
puts("DD halted");
} else if (strcmp(argv[1], "H"))) {
/* ask HHH */
if (HHH(DD)) {
puts("HHH says DD halts")
} else {
puts("HHH says DD doesn't halt") >>>>>>>>>>>> }
}
}
Show the trace/output with the D arguent and then with the H >>>>>>>>>>>> argument.
Well, did you try the code?
Or more simply, if you make a main() function in your UTM like >>>>>>>>>> this:
int main(void)
{
DD();
puts("DD halted");
}
what happens? (Substitute another logging function if puts >>>>>>>>>> isn't supported).
You seem to be evading this topic.
You are ignoring the differing process contexts that DD
correctly simulated by HHH and DD correctly simulated by HHH1 >>>>>>>>> fall under.
In other words, when HHH1 simulates DD it simulates DD calling >>>>>>>> HHH(DD,<empty execution trace>) which is correct, but when HHH >>>>>>>> simulates DD it simulates DD calling HHH(DD,<non-empty execution >>>>>>>> trace>) which changes the input.
1) Changing the input is not allowed 2) That HHH (and HHH1) takes >>>>>>>> an execution trace as input means it is DISQUALIFIED from being a >>>>>>>> halt decider / termination analyzer
then HHH(DD), DD(), HHH1(DD) never stop running
Changing the input is not allowed.
Changing the input is required otherwise Linz only proved that there >>>>> is one decider/input pair that gets the wrong answer and not that no >>>>> universal decider exists. He didn't prove that either.
decider in question was assumed at the start of the proof to be a
total halt decider, therefore the assumption that a total halt
decider exists is proven false.
No the only way the total decider is refuted would be by showing that
no H of the infinite set of H/D pairs can possibly derive the correct
return value.
We can't say here is one H that gets the wrong answer therefore every
H must get the wrong answer.
It doesn't f--king matter when answer H gives because D will always do
the opposite meaning H will ALWAYS give the wrong answer; this confirms
the extant Halting Problem proofs are correct and that the Halting
Problem is undecidable.
/Flibble
The advantage of a simulating halt decider is that no DD simulated by
HHH can possibly reach its own "do the opposite" code.
On 8/22/2025 2:01 PM, Kaz Kylheku wrote:
On 2025-08-22, olcott <polcott333@gmail.com> wrote:
The whole point of the HP seems to be to show that
some TMD's do not encode computable functions.
Every machine (that halts) computes a function.
Not sure why I wanted to say this, but a side note, it can be
computing iterations of a fractal function forever.
On 8/22/2025 10:59 AM, Richard Heathfield wrote:
On 22/08/2025 16:18, olcott wrote:
On 8/22/2025 12:12 AM, Richard Heathfield wrote:
On 22/08/2025 04:23, olcott wrote:
<snip>
I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.
That's a very lofty claim. What persuades you of its truth? Did you
ask an AI how deep your philosophical understanding is? I have no
doubt it was very reassuring.
I have been studying the nature of self-referential
paradox for 22 years.
That's nice.
I don't look up what others have said.
Might be an idea to start.
I reverse-engineer the actual truth.
Er... yeah. We've seen how that works out. Stopping isn't halting,
simulation doesn't have to simulate, all that.
Simulation of an input does provide the actual
behavior actually specified by this input as
opposed to and contrast with the behavior of
non-inputs.
On 8/22/2025 3:20 PM, Kaz Kylheku wrote:
On 2025-08-22, dbush <dbush.mobile@gmail.com> wrote:
On 8/22/2025 3:45 PM, olcott wrote:
On 8/22/2025 2:26 PM, dbush wrote:Which means you're changing the input.
If neither HHH nor HHH1 have access to the execution
trace data then HHH(DD), DD(), HHH1(DD) never stop
running
Changing the input is not allowed.
Statements like this only confuse Peter.
Changing the input is of course allowed, as long as you don't do
anything intellectually wrong: i.e. any conclusions that emerge from
your calculation are correct statements about the original input.
Consider a Turing Machine. The input is the tape. It changes
the tape!
Because a Turing Machine changes the tape, Olcott thinks that
his "x86 UTM" can likewise treat every bit in the system as
a symbol on a tape and flip it as it sees fit.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
Simultaneously evaluates an infinite set of
decider/input pairs, thus changing the input
is required otherwise the proof only shows
that there is one decider/input pair that gets
the wrong answer.
On 8/22/2025 3:19 AM, joes wrote:
Am Thu, 21 Aug 2025 17:12:27 -0500 schrieb olcott:
Its easy to see that DD correctly simulated by any HHH that can existDD, which calls HHH, which aborts after one recursion, can be simulated
cannot possibly reach its own "return" statement final halt state in the >>> same way that it can be seen that driving into any brick wall at 100 MPH >>> will not end well.
to completion by HHH_n, which aborts after more than one recursion.
Counter-factual for every HHH that can possibly exist.
_DD()
[00002162] 55 push ebp
[00002163] 8bec mov ebp,esp
[00002165] 51 push ecx
[00002166] 6862210000 push 00002162 // push DD
[0000216b] e862f4ffff call 000015d2 // call HHH
[00002170] 83c404 add esp,+04
[00002173] 8945fc mov [ebp-04],eax
[00002176] 837dfc00 cmp dword [ebp-04],+00
[0000217a] 7402 jz 0000217e
[0000217c] ebfe jmp 0000217c
[0000217e] 8b45fc mov eax,[ebp-04]
[00002181] 8be5 mov esp,ebp
[00002183] 5d pop ebp
[00002184] c3 et
Size in bytes:(0035) [00002184]
When N is a natural number and we ignore OOM errors
then when N instructions of DD are correctly emulated
by some HHH, none of these correctly emulated DD
instructions reach past their own machine address
0000216b.
When HHH aborts its simulation of DD zero instructions
of any level of simulation are emulated thus there is
no stack unwinding.
On 8/22/2025 10:02 AM, joes wrote:
Am Fri, 22 Aug 2025 09:36:47 -0500 schrieb olcott:
On 8/22/2025 3:19 AM, joes wrote:No, I was talking about simulating DD with something *different* than
DD, which calls HHH, which aborts after one recursion, can be simulated >>>> to completion by HHH_n, which aborts after more than one recursion.Counter-factual for every HHH that can possibly exist.
simulator that it calls.
HHH and HHH1 have identical source-code according to diff.
HHH(DD)==0 and HHH1(DD)==1 are both correct and the difference
is accounted for in that DD is being simulated in two different
process contexts. HHH1(DD) reaps the benefit of HHH(DD) having
already aborted its simulation. HHH(DD) cannot reap this same
benefit.
On 8/23/2025 3:49 AM, Fred. Zwarts wrote:
Op 22.aug.2025 om 19:11 schreef olcott:
On 8/22/2025 10:59 AM, Richard Heathfield wrote:
On 22/08/2025 16:18, olcott wrote:
On 8/22/2025 12:12 AM, Richard Heathfield wrote:
On 22/08/2025 04:23, olcott wrote:
<snip>
I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.
That's a very lofty claim. What persuades you of its truth?
Did you ask an AI how deep your philosophical understanding
is? I have no doubt it was very reassuring.
I have been studying the nature of self-referential
paradox for 22 years.
That's nice.
I don't look up what others have said.
Might be an idea to start.
I reverse-engineer the actual truth.
Er... yeah. We've seen how that works out. Stopping isn't
halting, simulation doesn't have to simulate, all that.
Simulation of an input does provide the actual
behavior actually specified by this input as
opposed to and contrast with the behavior of
non-inputs.
Only when it simulates up to the specified final halt state.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
On 8/22/2025 2:17 PM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 8/22/2025 1:43 PM, Alan Mackenzie wrote:
LLM systems don't think, not even part of the way through.
They do replicate the functional end result of thinking
and it is far too tedious to say it that way when the
end result is the same.
It's not clear what you mean by "replicate the functional end result of
thinking". It sounds like something a Vogon might say in one of Douglas
Adams's scripts.
It's clear that the outputs of LLMs are NOT the same as that of
intelligent thought. It is a delusion, possibly a dangerous one, to
believe otherwise.
*That is an inaccurate statement*
It is clear that in the cases where LLM systems hallucinate
that the result of their process is not the same result as
the result from a rational human mind.
It is also clear that in many many cases LLM systems
do derive a conclusion that matches or exceeds the
quality of human experts.
*It is great that you are reviewing my work again*
You are one of four competent and honest reviewers
that I was able to coax to review my work again.
Joes seems honest and possibly competent enough.
Dennis Bush may be neither competent enough nor
honest. He relies far too much on dogma utterly
bereft of any supporting reasoning. This may be
because he hardly understands the material.
Richard Heathfield may be sufficiently competent
and can be honest. The honestly seems to not be
consistent. Fred. Zwarts seems honest yet with
borderline competence. I may only need to make
my explanations more thorough.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Turing machine deciders only compute the mapping
from their inputs...
On 8/23/2025 11:06 AM, Richard Heathfield wrote:
On 23/08/2025 16:36, olcott wrote:
<snip>
Turing machine deciders only compute the mapping
from their inputs...
DD isn't a Turing machine. It's a C function.
And Because HHH is called by DD, HHH /is/ an input.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
On 8/23/2025 12:38 PM, Richard Heathfield wrote:
On 23/08/2025 17:27, olcott wrote:DD simulated by HHH is a way to determine the
On 8/23/2025 11:06 AM, Richard Heathfield wrote:
On 23/08/2025 16:36, olcott wrote:
<snip>
Turing machine deciders only compute the mapping
from their inputs...
DD isn't a Turing machine. It's a C function.
And Because HHH is called by DD, HHH /is/ an input.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
Reaching its own simulated return statement isn't the issue.
actual behavior that the actual input actually
specifies.
Halt deciders only report on the actual behavior
that their actual input actually specifies.
Turing machine deciders only compute the mapping
from their inputs...
On 8/23/2025 10:34 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 8/22/2025 2:17 PM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 8/22/2025 1:43 PM, Alan Mackenzie wrote:
[ .... ]
LLM systems don't think, not even part of the way through.
They do replicate the functional end result of thinking
and it is far too tedious to say it that way when the
end result is the same.
It's not clear what you mean by "replicate the functional end result of >>>> thinking". It sounds like something a Vogon might say in one of
Douglas
Adams's scripts.
It's clear that the outputs of LLMs are NOT the same as that of
intelligent thought. It is a delusion, possibly a dangerous one, to
believe otherwise.
*That is an inaccurate statement*
It is clear that in the cases where LLM systems hallucinate
that the result of their process is not the same result as
the result from a rational human mind.
Given how difficult it is to determine when these systems are
hallucinating, for most purposes it is advisable to assume they are
unless proven otherwise.
It is also clear that in many many cases LLM systems
do derive a conclusion that matches or exceeds the
quality of human experts.
It's not clear to me, but what do I know?
They passed the Bar exam. https://www.abajournal.com/web/article/latest- version-of-chatgpt-aces-the-bar-exam-with-score-in-90th-percentile
*It is great that you are reviewing my work again*
You are one of four competent and honest reviewers
that I was able to coax to review my work again.
Joes seems honest and possibly competent enough.
Dennis Bush may be neither competent enough nor
honest. He relies far too much on dogma utterly
bereft of any supporting reasoning. This may be
because he hardly understands the material.
Richard Heathfield may be sufficiently competent
and can be honest. The honestly seems to not be
consistent. Fred. Zwarts seems honest yet with
borderline competence. I may only need to make
my explanations more thorough.
All the other people on this newsgroup are honest and most are competent
too. Some indeed have spent their working lives teaching this stuff, and >> most of the rest also have relevant academic qualifications and are or
have been professional programmers.
The suggestion that a mass of dishonest people has spontaneously
assembled here surely can't be the case.
The only motive for half of the regulars of this group
is to denigrate my work even if they must do this in
direct contradiction of the verified facts such as this
verified fact:
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
That's just not the way the
world works.
That may not be the way that the world works yet it
is the way that several people in this groups works
regarding my ideas.
Dishonest people are few and far between, though not as few
Not so much with modern day politics.
Now we have a whole political party that supports
Donald Trump's lies about election fraud.
These same people have been indoctrinated into
rejecting climate change. 45% pf the US electorate
have lies fully integrated into their worldview.
as many of us would like. All the posters here care about the truth,
mathematical truth in particular. That, I think, is why they spend
months, or even years, exchanging views with you.
I trust that you are one of the four honest ones.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
On 8/23/2025 12:37 PM, dbush wrote:
On 8/23/2025 1:25 PM, olcott wrote:I have explained this and you simply don't
On 8/23/2025 12:16 PM, dbush wrote:
On 8/23/2025 1:00 PM, olcott wrote:
On 8/23/2025 11:55 AM, dbush wrote:And there is no such infinite set in the Linz proof, only a *single*
On 8/23/2025 12:51 PM, olcott wrote:
On 8/23/2025 11:43 AM, dbush wrote:
On 8/23/2025 12:37 PM, olcott wrote:
On 8/23/2025 11:34 AM, dbush wrote:
On 8/23/2025 12:27 PM, olcott wrote:
On 8/23/2025 11:06 AM, Richard Heathfield wrote:
On 23/08/2025 16:36, olcott wrote:
<snip>
Turing machine deciders only compute the mapping
from their inputs...
DD isn't a Turing machine. It's a C function.
And Because HHH is called by DD, HHH /is/ an input.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
In other words, you're describing what a non-input would do >>>>>>>>>> and then report on that non-input.
Reporting on non-inputs is not allowed.
Like the Linz proof that you are not bright enough
to understand
No, that would be you, as you've clearly demonstrated that you >>>>>>>> don't understand proof by contradiction.
I simultaneously examine an infiniteWhich is not what the Linz proof does.
set of decider/input pairs.
Line 1 of the proof:
-----
We assume the contrary, namely that there exists an algorithm, >>>>>>>> and consequently some Turing machine H, that solves the halting >>>>>>>> problem
-----
i.e. there is a *single* H which is assumed to be a total halt >>>>>>>> decider, and a *single* H^ is built from it.
We assume that some H exists
Which is a total halt decider
and then we examineA *single* H^ built from H we see that when (H^,H^) is given to H, >>>>>> that what H reports is the opposite of what H^(H^) does.
This is a contradiction, proving that the assumption that a total
halt decider exists is false.
Every embedded_H element of the infinite set
of Ĥ/⟨Ĥ⟩ pairs
H which is assumed to be a total halt decider, and a *single* Ĥ
built from it.
If you disagree, show where in the Linz proof where more than a
single H or Ĥ is used. Given as long as you've spent on this, I
expect you to be able to immediately identify where the proof says
this.
Get someone else to explain to you that you are wrong.
Your lack of explanation indicates that you know that the Linz proof
doesn't work with an infinite set of decider/input pairs and are lying
about it.
believe me so ask someone that you do believe.
On 8/23/2025 12:51 PM, Richard Heathfield wrote:
What about the behaviour of DD(), the C function? You keep ignoring it
in favour of DD-as-simulated-by-a-function-that-can't-see-75%-of-the-
code.
Turing machine deciders only compute the mapping
from their inputs...
On 8/23/2025 12:42 PM, dbush wrote:
On 8/23/2025 1:39 PM, olcott wrote:
On 8/23/2025 12:37 PM, dbush wrote:
On 8/23/2025 1:25 PM, olcott wrote:I have explained this and you simply don't
On 8/23/2025 12:16 PM, dbush wrote:
On 8/23/2025 1:00 PM, olcott wrote:
On 8/23/2025 11:55 AM, dbush wrote:And there is no such infinite set in the Linz proof, only a
On 8/23/2025 12:51 PM, olcott wrote:
On 8/23/2025 11:43 AM, dbush wrote:
On 8/23/2025 12:37 PM, olcott wrote:
On 8/23/2025 11:34 AM, dbush wrote:
On 8/23/2025 12:27 PM, olcott wrote:
On 8/23/2025 11:06 AM, Richard Heathfield wrote:In other words, you're describing what a non-input would do >>>>>>>>>>>> and then report on that non-input.
On 23/08/2025 16:36, olcott wrote:
<snip>
Turing machine deciders only compute the mapping >>>>>>>>>>>>>>> from their inputs...
DD isn't a Turing machine. It's a C function.
And Because HHH is called by DD, HHH /is/ an input. >>>>>>>>>>>>>>
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state. >>>>>>>>>>>>
Reporting on non-inputs is not allowed.
Like the Linz proof that you are not bright enough
to understand
No, that would be you, as you've clearly demonstrated that you >>>>>>>>>> don't understand proof by contradiction.
I simultaneously examine an infiniteWhich is not what the Linz proof does.
set of decider/input pairs.
Line 1 of the proof:
-----
We assume the contrary, namely that there exists an algorithm, >>>>>>>>>> and consequently some Turing machine H, that solves the
halting problem
-----
i.e. there is a *single* H which is assumed to be a total halt >>>>>>>>>> decider, and a *single* H^ is built from it.
We assume that some H exists
Which is a total halt decider
and then we examineA *single* H^ built from H we see that when (H^,H^) is given to >>>>>>>> H, that what H reports is the opposite of what H^(H^) does.
This is a contradiction, proving that the assumption that a
total halt decider exists is false.
Every embedded_H element of the infinite set
of Ĥ/⟨Ĥ⟩ pairs
*single* H which is assumed to be a total halt decider, and a
*single* Ĥ built from it.
If you disagree, show where in the Linz proof where more than a
single H or Ĥ is used. Given as long as you've spent on this, I >>>>>> expect you to be able to immediately identify where the proof says >>>>>> this.
Get someone else to explain to you that you are wrong.
Your lack of explanation indicates that you know that the Linz proof
doesn't work with an infinite set of decider/input pairs and are
lying about it.
believe me so ask someone that you do believe.
Last chance:
Show exactly where in the Linz proof more than a single H or Ĥ is used. >>>>
Failure to show this in your next reply or within one hour of your
next post in this newsgroup will be taken as your official on-the-
record admission that the Linz proof does in fact use only a
*single* H which is assumed to be a total halt decider and a
*single* Ĥ built from it, and that therefore any attempted
refutation involving more than that is INVALID
Let the record show that Peter Olcott made no attempt to show where in
the Linz proof more than a single H or Ĥ is used. Therefore:
Let The Record Show:
That Dennis Bush is too stupid to understand that
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
On 8/23/2025 12:51 PM, Richard Heathfield wrote:
On 23/08/2025 18:42, olcott wrote:
On 8/23/2025 12:38 PM, Richard Heathfield wrote:
On 23/08/2025 17:27, olcott wrote:DD simulated by HHH is a way to determine the
On 8/23/2025 11:06 AM, Richard Heathfield wrote:
On 23/08/2025 16:36, olcott wrote:
<snip>
Turing machine deciders only compute the mapping
from their inputs...
DD isn't a Turing machine. It's a C function.
And Because HHH is called by DD, HHH /is/ an input.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
Reaching its own simulated return statement isn't the issue.
actual behavior that the actual input actually
specifies.
What about the behaviour of DD(), the C function? You keep
ignoring it in favour of
DD-as-simulated-by-a-function-that-can't-see-75%-of-the-code.
Turing machine
deciders
only compute the mapping
from their inputs...
That Dennis Bush is too stupid to understand that
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
On 8/23/2025 2:53 PM, Richard Heathfield wrote:
You don't concede that DD (the C function) is an input, so you
don't have a meaningful input.
The kind of thing that a technically incompetent person would say.
On 23/08/2025 18:59, olcott wrote:
On 8/23/2025 12:51 PM, Richard Heathfield wrote:
On 23/08/2025 18:42, olcott wrote:
On 8/23/2025 12:38 PM, Richard Heathfield wrote:
On 23/08/2025 17:27, olcott wrote:DD simulated by HHH is a way to determine the
On 8/23/2025 11:06 AM, Richard Heathfield wrote:
On 23/08/2025 16:36, olcott wrote:
<snip>
Turing machine deciders only compute the mapping
from their inputs...
DD isn't a Turing machine. It's a C function.
And Because HHH is called by DD, HHH /is/ an input.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
Reaching its own simulated return statement isn't the issue.
actual behavior that the actual input actually
specifies.
What about the behaviour of DD(), the C function? You keep ignoring
it in favour of DD-as-simulated-by-a-function-that-can't-see-75%-of-
the-code.
Turing machine
You don't have a TM. DD is a C function.
deciders
You don't have a working decider.
only compute the mapping
...incorrectly...
from their inputs...
You don't concede that DD (the C function) is an input, so you don't
have a meaningful input.
<puerile repetition snipped>
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program that the
decider cannot correctly decide, proving that the decider is /not/
universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input. Dennis Bush thinks that Linz
does do this.
On 8/23/2025 3:15 PM, dbush wrote:
On 8/23/2025 4:13 PM, olcott wrote:
On 8/23/2025 2:53 PM, Richard Heathfield wrote:
On 23/08/2025 18:59, olcott wrote:
On 8/23/2025 12:51 PM, Richard Heathfield wrote:
On 23/08/2025 18:42, olcott wrote:
On 8/23/2025 12:38 PM, Richard Heathfield wrote:
On 23/08/2025 17:27, olcott wrote:DD simulated by HHH is a way to determine the
On 8/23/2025 11:06 AM, Richard Heathfield wrote:
On 23/08/2025 16:36, olcott wrote:
<snip>
Turing machine deciders only compute the mapping
from their inputs...
DD isn't a Turing machine. It's a C function.
And Because HHH is called by DD, HHH /is/ an input.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
Reaching its own simulated return statement isn't the issue.
actual behavior that the actual input actually
specifies.
What about the behaviour of DD(), the C function? You keep
ignoring it in favour of DD-as-simulated-by-a-function-that-can't- >>>>>> see-75%- of- the-code.
Turing machine
You don't have a TM. DD is a C function.
deciders
You don't have a working decider.
only compute the mapping
...incorrectly...
from their inputs...
You don't concede that DD (the C function) is an input, so you don't
have a meaningful input.
The kind of thing that a technically incompetent
person would say. The machine address of the finite
string of machine code is an input to HHH(DD).
But not the only input. An execution trace is also an input, so HHH
is DISQUALIFIED from being a halt decider / termination analyzer.
When we eliminate the static data then the
fact that DD() never halts proves that HHH(DD)==0.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program that the
decider cannot correctly decide, proving that the decider is /not/
universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input. Dennis Bush thinks that Linz
does do this.
But you have admitted on the record that
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program that
the decider cannot correctly decide, proving that the decider is / >>>>>> not/ universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input. Dennis Bush thinks that Linz
does do this.
But you have admitted on the record that
Says the person that doesn't understand proof by contradiction more
than 50 years after he learned it.
It is not that I don't know proof by contradiction.
It is that I am not too stupid to not notice when
no contradiction is actually formed.
Not only are you too stupid to see this it is
willful stupidity thus dishonestly.
When HHH reports that DD correctly simulated
cannot possibly halt no contradiction is formed.
That you are too stupid to know that HHH(DD) would
report on this correct basis is yet again your own
stupidity.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:40 PM, olcott wrote:
On 8/23/2025 3:15 PM, dbush wrote:Then you change the input and decide on that non-input.
On 8/23/2025 4:13 PM, olcott wrote:
On 8/23/2025 2:53 PM, Richard Heathfield wrote:
On 23/08/2025 18:59, olcott wrote:
On 8/23/2025 12:51 PM, Richard Heathfield wrote:
On 23/08/2025 18:42, olcott wrote:
On 8/23/2025 12:38 PM, Richard Heathfield wrote:
On 23/08/2025 17:27, olcott wrote:actual behavior that the actual input actually
On 8/23/2025 11:06 AM, Richard Heathfield wrote:
On 23/08/2025 16:36, olcott wrote:
<snip>
Turing machine deciders only compute the mapping
from their inputs...
DD isn't a Turing machine. It's a C function.
And Because HHH is called by DD, HHH /is/ an input.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
Reaching its own simulated return statement isn't the issue. >>>>>>>>> DD simulated by HHH is a way to determine the
specifies.
What about the behaviour of DD(), the C function? You keep
ignoring it in favour of DD-as-simulated-by-a-function-that-
can't- see-75%- of- the-code.
Turing machine
You don't have a TM. DD is a C function.
deciders
You don't have a working decider.
only compute the mapping
...incorrectly...
from their inputs...
You don't concede that DD (the C function) is an input, so you
don't have a meaningful input.
The kind of thing that a technically incompetent
person would say. The machine address of the finite
string of machine code is an input to HHH(DD).
But not the only input. An execution trace is also an input, so HHH
is DISQUALIFIED from being a halt decider / termination analyzer.
When we eliminate the static data
Deciding on non-inputs is not allowed.
We could keep everything else the same and
append a NOP instruction to DD. You are too
stupid to understand that this would not change
the behavior of DD correctly simulated by HHH.
Any change the does not change the behavior of
DD correctly simulated by HHH is a change of
no relevant consequence. You are too stupid to
know what those words mean.
On 8/23/2025 4:22 PM, dbush wrote:
On 8/23/2025 5:12 PM, olcott wrote:
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed? >>>>>>>>
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program that >>>>>>>> the decider cannot correctly decide, proving that the decider
is / not/ universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input. Dennis Bush thinks that Linz
does do this.
But you have admitted on the record that
Says the person that doesn't understand proof by contradiction more
than 50 years after he learned it.
I showed in the Linz proof where only one H is being used. So
unless you show where more than one H or H^ is used, your below
admission stands.
In other words Linz shows that one H
Which is assumed to be a total halt decider.
gets the
wrong answer on one input
Proving the assumption that a total halt decider exists is false
Very stupid. It only proves that the one H
is not a total halt decider.
On 8/23/2025 4:39 PM, dbush wrote:
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the mapping
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:But you have admitted on the record that
On 23/08/2025 19:11, olcott wrote:Linz does not attempt to prove that there is one H that gets the >>>>>>>>> wrong answer for one input. Dennis Bush thinks that Linz does do >>>>>>>>> this.
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous evaluation >>>>>>>>>>> of an infinite set of decider/input pairs and too stubborn to >>>>>>>>>>> check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be
constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program >>>>>>>>>> that the decider cannot correctly decide, proving that the >>>>>>>>>> decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction more >>>>>> than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no contradiction
is actually formed.
Not only are you too stupid to see this it is willful stupidity thus >>>>> dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly halt no >>>>> contradiction is formed.In other words, the function that the HHH you implemented computes is
not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the
following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
That you are too stupid to know that HHH(DD) would report on thisIt is you that are too stupid to know that HHH is not a halt decider
correct basis is yet again your own stupidity.
because it doesn't meet the requirements to be one:
from its inputs.
It is common knowledge that the caller of a function is not the input
to this same function.
Therefore a halt decider is not supposed to report on the behavior of
its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their inputs...
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program that the
decider cannot correctly decide, proving that the decider is /not/
universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input. Dennis Bush thinks that Linz
does do this.
On 8/23/2025 4:49 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
On 8/23/2025 4:39 PM, dbush wrote:
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the mapping
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:But you have admitted on the record that
On 23/08/2025 19:11, olcott wrote:Linz does not attempt to prove that there is one H that gets >>>>>>>>>>> the wrong answer for one input. Dennis Bush thinks that Linz >>>>>>>>>>> does do this.
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs and too >>>>>>>>>>>>> stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that. >>>>>>>>>>>>
Is it possible for a universal TM halt decider to be
constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program >>>>>>>>>>>> that the decider cannot correctly decide, proving that the >>>>>>>>>>>> decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction >>>>>>>> more than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no contradiction >>>>>>> is actually formed.
Not only are you too stupid to see this it is willful stupidity
thus dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly halt >>>>>>> no contradiction is formed.In other words, the function that the HHH you implemented computes >>>>>> is not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of
instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes
the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly >>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
That you are too stupid to know that HHH(DD) would report on this >>>>>>> correct basis is yet again your own stupidity.It is you that are too stupid to know that HHH is not a halt
decider because it doesn't meet the requirements to be one:
from its inputs.
It is common knowledge that the caller of a function is not the
input to this same function.
Therefore a halt decider is not supposed to report on the behavior
of its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their inputs...
Sure and DD is an input to HHH as well as being a caller of HHH.
/Flibble
No the DD input is a finite string that that has no behavior and DD() is
an executing process that has behavior.
On 8/23/2025 5:06 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:56:35 -0500, olcott wrote:
On 8/23/2025 4:49 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
On 8/23/2025 4:39 PM, dbush wrote:
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the mapping >>>>>>> from its inputs.
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:But you have admitted on the record that
On 23/08/2025 19:11, olcott wrote:Linz does not attempt to prove that there is one H that gets >>>>>>>>>>>>> the wrong answer for one input. Dennis Bush thinks that Linz >>>>>>>>>>>>> does do this.
<snip>
That Dennis Bush is too stupid to understand that >>>>>>>>>>>>>>You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous >>>>>>>>>>>>>>> evaluation of an infinite set of decider/input pairs and >>>>>>>>>>>>>>> too stubborn to check with others that he trusts. >>>>>>>>>>>>>>
No, the conventional HP proof is much simpler than that. >>>>>>>>>>>>>>
Is it possible for a universal TM halt decider to be >>>>>>>>>>>>>> constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program >>>>>>>>>>>>>> that the decider cannot correctly decide, proving that the >>>>>>>>>>>>>> decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction >>>>>>>>>> more than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no
contradiction is actually formed.
Not only are you too stupid to see this it is willful stupidity >>>>>>>>> thus dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly >>>>>>>>> halt no contradiction is formed.In other words, the function that the HHH you implemented
computes is not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of
instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes >>>>>>>> the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed
directly (<X>,Y) maps to 0 if and only if X(Y) does not halt when >>>>>>>> executed directly
That you are too stupid to know that HHH(DD) would report on >>>>>>>>> this correct basis is yet again your own stupidity.It is you that are too stupid to know that HHH is not a halt
decider because it doesn't meet the requirements to be one:
It is common knowledge that the caller of a function is not the
input to this same function.
Therefore a halt decider is not supposed to report on the behavior >>>>>>> of its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their
inputs...
Sure and DD is an input to HHH as well as being a caller of HHH.
/Flibble
No the DD input is a finite string that that has no behavior and DD()
is an executing process that has behavior.
The DD input is indeed a description of DD the executing function; they
are equivalent: HHH will *analyse* the behaviour of DD the executing
function using the *description* of DD. In the case of an SHD that
input might be machine code obtained taking a pointer to DD the
executing function.
To put it more simply DD the input *encodes* the behaviour of DD the
executing function (the ultimate caller of HHH).
/Flibble
When you assume away the fact that DD calls HHH(DD)
in recursive simulation you get incorrect results.
On 8/23/2025 4:39 PM, dbush wrote:
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed? >>>>>>>>>>
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program >>>>>>>>>> that the decider cannot correctly decide, proving that the >>>>>>>>>> decider is / not/ universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input. Dennis Bush thinks that Linz
does do this.
But you have admitted on the record that
Says the person that doesn't understand proof by contradiction
more than 50 years after he learned it.
It is not that I don't know proof by contradiction.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when
no contradiction is actually formed.
Not only are you too stupid to see this it is
willful stupidity thus dishonestly.
Projection.
When HHH reports that DD correctly simulated
cannot possibly halt no contradiction is formed.
In other words, the function that the HHH you implemented computes
is not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of
instructions) X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes
the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
That you are too stupid to know that HHH(DD) would
report on this correct basis is yet again your own
stupidity.
It is you that are too stupid to know that HHH is not a halt decider
because it doesn't meet the requirements to be one:
It is common knowledge that HHH is supposed
to compute the mapping from its inputs.
It is common knowledge that the caller of
a function is not the input to this same function.
Therefore a halt decider is not supposed to report
on the behavior of its caller is derived from common
knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping
from their inputs...
On 8/23/2025 5:06 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:56:35 -0500, olcott wrote:
On 8/23/2025 4:49 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
On 8/23/2025 4:39 PM, dbush wrote:Sure and DD is an input to HHH as well as being a caller of HHH.
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the mapping >>>>>>> from its inputs.
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:But you have admitted on the record that
On 23/08/2025 19:11, olcott wrote:Linz does not attempt to prove that there is one H that gets >>>>>>>>>>>>> the wrong answer for one input. Dennis Bush thinks that Linz >>>>>>>>>>>>> does do this.
<snip>
That Dennis Bush is too stupid to understand that >>>>>>>>>>>>>>You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous >>>>>>>>>>>>>>> evaluation of an infinite set of decider/input pairs and too >>>>>>>>>>>>>>> stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that. >>>>>>>>>>>>>>
Is it possible for a universal TM halt decider to be >>>>>>>>>>>>>> constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program >>>>>>>>>>>>>> that the decider cannot correctly decide, proving that the >>>>>>>>>>>>>> decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction >>>>>>>>>> more than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no contradiction >>>>>>>>> is actually formed.
Not only are you too stupid to see this it is willful stupidity >>>>>>>>> thus dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly halt >>>>>>>>> no contradiction is formed.In other words, the function that the HHH you implemented computes >>>>>>>> is not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of
instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes >>>>>>>> the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly >>>>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed >>>>>>>> directly
That you are too stupid to know that HHH(DD) would report on this >>>>>>>>> correct basis is yet again your own stupidity.It is you that are too stupid to know that HHH is not a halt
decider because it doesn't meet the requirements to be one:
It is common knowledge that the caller of a function is not the
input to this same function.
Therefore a halt decider is not supposed to report on the behavior >>>>>>> of its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their inputs... >>>>
/Flibble
No the DD input is a finite string that that has no behavior and DD() is >>> an executing process that has behavior.
The DD input is indeed a description of DD the executing function; they
are equivalent: HHH will *analyse* the behaviour of DD the executing
function using the *description* of DD. In the case of an SHD that input >> might be machine code obtained taking a pointer to DD the executing
function.
To put it more simply DD the input *encodes* the behaviour of DD the
executing function (the ultimate caller of HHH).
/Flibble
When you assume away the fact that DD calls HHH(DD)
in recursive simulation you get incorrect results.
On 8/23/2025 5:29 PM, Mr Flibble BSc (Hons) wrote:
On Sat, 23 Aug 2025 17:24:50 -0500, olcott wrote:
On 8/23/2025 5:06 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:56:35 -0500, olcott wrote:
On 8/23/2025 4:49 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
On 8/23/2025 4:39 PM, dbush wrote:
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the mapping >>>>>>>>> from its inputs.
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote: >>>>>>>>>>>>>>>> On 23/08/2025 19:11, olcott wrote:But you have admitted on the record that
Linz does not attempt to prove that there is one H that gets >>>>>>>>>>>>>>> the wrong answer for one input. Dennis Bush thinks that Linz >>>>>>>>>>>>>>> does do this.
<snip>
That Dennis Bush is too stupid to understand that >>>>>>>>>>>>>>>>You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous >>>>>>>>>>>>>>>>> evaluation of an infinite set of decider/input pairs and >>>>>>>>>>>>>>>>> too stubborn to check with others that he trusts. >>>>>>>>>>>>>>>>
No, the conventional HP proof is much simpler than that. >>>>>>>>>>>>>>>>
Is it possible for a universal TM halt decider to be >>>>>>>>>>>>>>>> constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program >>>>>>>>>>>>>>>> that the decider cannot correctly decide, proving that the >>>>>>>>>>>>>>>> decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction >>>>>>>>>>>> more than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no
contradiction is actually formed.
Not only are you too stupid to see this it is willful stupidity >>>>>>>>>>> thus dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly >>>>>>>>>>> halt no contradiction is formed.In other words, the function that the HHH you implemented
computes is not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of
instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes >>>>>>>>>> the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed
directly (<X>,Y) maps to 0 if and only if X(Y) does not halt when >>>>>>>>>> executed directly
That you are too stupid to know that HHH(DD) would report on >>>>>>>>>>> this correct basis is yet again your own stupidity.It is you that are too stupid to know that HHH is not a halt >>>>>>>>>> decider because it doesn't meet the requirements to be one: >>>>>>>>>>
It is common knowledge that the caller of a function is not the >>>>>>>>> input to this same function.
Therefore a halt decider is not supposed to report on the behavior >>>>>>>>> of its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their
inputs...
Sure and DD is an input to HHH as well as being a caller of HHH.
/Flibble
No the DD input is a finite string that that has no behavior and DD() >>>>> is an executing process that has behavior.
The DD input is indeed a description of DD the executing function; they >>>> are equivalent: HHH will *analyse* the behaviour of DD the executing
function using the *description* of DD. In the case of an SHD that
input might be machine code obtained taking a pointer to DD the
executing function.
To put it more simply DD the input *encodes* the behaviour of DD the
executing function (the ultimate caller of HHH).
/Flibble
When you assume away the fact that DD calls HHH(DD)
in recursive simulation you get incorrect results.
You've got nothin'.
/Flibble
That you can understand.
On 8/23/2025 4:49 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
On 8/23/2025 4:39 PM, dbush wrote:
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the mapping
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:But you have admitted on the record that
On 23/08/2025 19:11, olcott wrote:Linz does not attempt to prove that there is one H that gets the >>>>>>>>>>> wrong answer for one input. Dennis Bush thinks that Linz does do >>>>>>>>>>> this.
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous evaluation >>>>>>>>>>>>> of an infinite set of decider/input pairs and too stubborn to >>>>>>>>>>>>> check with others that he trusts.
No, the conventional HP proof is much simpler than that. >>>>>>>>>>>>
Is it possible for a universal TM halt decider to be
constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program >>>>>>>>>>>> that the decider cannot correctly decide, proving that the >>>>>>>>>>>> decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction more >>>>>>>> than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no contradiction >>>>>>> is actually formed.
Not only are you too stupid to see this it is willful stupidity thus >>>>>>> dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly halt no >>>>>>> contradiction is formed.In other words, the function that the HHH you implemented computes is >>>>>> not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of instructions) >>>>>> X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the >>>>>> following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly >>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
That you are too stupid to know that HHH(DD) would report on this >>>>>>> correct basis is yet again your own stupidity.It is you that are too stupid to know that HHH is not a halt decider >>>>>> because it doesn't meet the requirements to be one:
from its inputs.
It is common knowledge that the caller of a function is not the input >>>>> to this same function.
Therefore a halt decider is not supposed to report on the behavior of >>>>> its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their inputs...
Sure and DD is an input to HHH as well as being a caller of HHH.
/Flibble
No the DD input is a finite string that that has
no behavior and DD() is an executing process that
has behavior.
On 8/23/25 5:56 PM, olcott wrote:
On 8/23/2025 4:49 PM, Mr Flibble wrote:So, how do you answer about the behavior of a string that doesn't have behavior?
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
On 8/23/2025 4:39 PM, dbush wrote:
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the mapping >>>>>> from its inputs.
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:But you have admitted on the record that
On 23/08/2025 19:11, olcott wrote:Linz does not attempt to prove that there is one H that gets >>>>>>>>>>>> the wrong answer for one input. Dennis Bush thinks that Linz >>>>>>>>>>>> does do this.
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous >>>>>>>>>>>>>> evaluation of an infinite set of decider/input pairs and >>>>>>>>>>>>>> too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that. >>>>>>>>>>>>>
Is it possible for a universal TM halt decider to be >>>>>>>>>>>>> constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program >>>>>>>>>>>>> that the decider cannot correctly decide, proving that the >>>>>>>>>>>>> decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction >>>>>>>>> more than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no
contradiction is actually formed.
Not only are you too stupid to see this it is willful stupidity >>>>>>>> thus dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly halt >>>>>>>> no contradiction is formed.In other words, the function that the HHH you implemented computes >>>>>>> is not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of
instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes >>>>>>> the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly >>>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed >>>>>>> directly
That you are too stupid to know that HHH(DD) would report on this >>>>>>>> correct basis is yet again your own stupidity.It is you that are too stupid to know that HHH is not a halt
decider because it doesn't meet the requirements to be one:
It is common knowledge that the caller of a function is not the
input to this same function.
Therefore a halt decider is not supposed to report on the behavior >>>>>> of its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their inputs...
Sure and DD is an input to HHH as well as being a caller of HHH.
/Flibble
No the DD input is a finite string that that has no behavior and DD()
is an executing process that has behavior.
You just contradicted your own arguement.
The problem is the answer isn't based on "the behavior of the input" but
"the behavior of what the input represents", which is the program DD
directly executed.
Sorry, you are just showing your ignorance of what you are talking
about.
On 8/23/2025 4:56 PM, Kaz Kylheku wrote:
On 2025-08-23, olcott <polcott333@gmail.com> wrote:
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program that the
decider cannot correctly decide, proving that the decider is /not/
universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input. Dennis Bush thinks that Linz
does do this.
You don't seem to understand proofs that generalize due to
implicit (or even explicit?) universal quanitization.
Turing Machine Linz Ĥ applied to its own machine description ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
We can only do that with a template such as above.
Linz correctly claims that there does not exist
any Ĥ.embedded_H that transitions to its own state
conforming to the behavior of Ĥ applied to ⟨Ĥ⟩.
Yet this is not the same thing as saying that
Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would be incorrect when it
transitions to Ĥ.qn on the basis that
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H cannot
possibly reach its own simulated final halt state
of ⟨Ĥ.qn⟩.
*There is no contradiction formed on that basis*
When we initially assume that a halting decider H is possible, we are
not specifying any details about H. Therefore, H denotes any decider
whatsoever.
It is because of this that the argument works.
We can reframe it like this: suppose that there exist universal halting
deciders. These constitute a set: Hs.
Let H be any element chosen from the set Hs.
For any such H, a test case can be constructed which embeds H in a way
that contradicts H's decision.
No matter how we encode this H, thus implicitly
referring to the infinite set of every H.
Therefore H is not a universal decider and cannot be an element of Hs.
Therefore Hs is empty: there are no universal deciders.
Note that I Used "For any such H" to make it clear that the argument is
generalizing H to the whole set; it is universally quantified.
Yes Dennis Bush just doesn't get that.
He is going by the words of Linz rather than
the nature of how all of these proofs work.
By the time people are in second year undergrad, they typically don't
need such a thing spelled out as the obvious generalization implicit in
an argument.
Dennis Bush may have never gotten that far.
I finished all of the CS courses for a CS
degree in about the top 20% of my class.
I ended up with about 200 credits when a
bachelor's degree only requires 125. I went
to college full time for 6.5 years including
Summers.
In general, there is a convention in logic that free free variables are
implicitly universally quantified, so that when we speak about some H,
it denotes all instances of its class.
Yet in the HP proofs it is not just
some H it is an decider/input pair
matching a template.
For instance, suppose I say "if X is a man, X is mortal". In notation,
man(x) -> mortal(x). This is a condensed way of giving the statement:
∀ X : man(x) -> mortal(x)
Yes I have know this notation for at least a decade.
(I hope you can see the ∀ symbol: the universal quantifier "forall".)
In the condensed statement man(x) -> mortal(x), x is a free variable,
not bound by any quantifier. Therefore we implicitly bind it to the
univeral quantifier. I.e. we understand it not to be free, but to be
expression the idea that X denotes any element at all, making the
formula universally quantified over all possible x.
Yet "man" also means mankind.
This is how you must understand the condensed halting arguments. The
dummy variable H (or what have you) is universally quantified, denoting
all deciders.
Yes maybe Dennis Bush will believe you.
On 8/23/2025 6:09 PM, Mr Flibble BSc (Hons) wrote:
On Sat, 23 Aug 2025 19:06:20 -0400, Richard Damon wrote:
On 8/23/25 5:56 PM, olcott wrote:
On 8/23/2025 4:49 PM, Mr Flibble wrote:So, how do you answer about the behavior of a string that doesn't have
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
On 8/23/2025 4:39 PM, dbush wrote:
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:But you have admitted on the record that
On 23/08/2025 19:11, olcott wrote:Linz does not attempt to prove that there is one H that >>>>>>>>>>>>>> gets the wrong answer for one input. Dennis Bush thinks >>>>>>>>>>>>>> that Linz does do this.
<snip>
That Dennis Bush is too stupid to understand that >>>>>>>>>>>>>>>You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous >>>>>>>>>>>>>>>> evaluation of an infinite set of decider/input pairs and >>>>>>>>>>>>>>>> too stubborn to check with others that he trusts. >>>>>>>>>>>>>>>
No, the conventional HP proof is much simpler than that. >>>>>>>>>>>>>>>
Is it possible for a universal TM halt decider to be >>>>>>>>>>>>>>> constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a >>>>>>>>>>>>>>> program that the decider cannot correctly decide, proving >>>>>>>>>>>>>>> that the decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction >>>>>>>>>>> more than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no
contradiction is actually formed.
Not only are you too stupid to see this it is willful stupidity >>>>>>>>>> thus dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly >>>>>>>>>> halt no contradiction is formed.In other words, the function that the HHH you implemented
computes is not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of
instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that
computes the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed
directly (<X>,Y) maps to 0 if and only if X(Y) does not halt >>>>>>>>> when executed directly
That you are too stupid to know that HHH(DD) would report on >>>>>>>>>> this correct basis is yet again your own stupidity.It is you that are too stupid to know that HHH is not a halt >>>>>>>>> decider because it doesn't meet the requirements to be one:
mapping from its inputs.
It is common knowledge that the caller of a function is not the >>>>>>>> input to this same function.
Therefore a halt decider is not supposed to report on the
behavior of its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their
inputs...
Sure and DD is an input to HHH as well as being a caller of HHH.
/Flibble
No the DD input is a finite string that that has no behavior and DD()
is an executing process that has behavior.
behavior?
You just contradicted your own arguement.
The problem is the answer isn't based on "the behavior of the input"
but "the behavior of what the input represents", which is the program
DD directly executed.
Sorry, you are just showing your ignorance of what you are talking
about.
Indeed he is but alas no matter how many us of tell him that and no
matter how many times we tell him it will make no difference: Olcott's
wilful obtuseness knows no bounds.
/Flibble
That you do not bother to pay 100% complete attention is not my mistake.
That DD correctly simulated by and HHH that can possibly exist cannot
reach its own simulated final halt state is a point that has been:
(a) Dishonestly dodged (b) Failed to be understood (c) Lied about Never
has been my mistake for any time in the last three years.
On 8/23/2025 6:09 PM, Mr Flibble BSc (Hons) wrote:
On Sat, 23 Aug 2025 19:06:20 -0400, Richard Damon wrote:
On 8/23/25 5:56 PM, olcott wrote:
On 8/23/2025 4:49 PM, Mr Flibble wrote:So, how do you answer about the behavior of a string that doesn't have
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
On 8/23/2025 4:39 PM, dbush wrote:Sure and DD is an input to HHH as well as being a caller of HHH.
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the mapping >>>>>>>> from its inputs.
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:But you have admitted on the record that
On 23/08/2025 19:11, olcott wrote:Linz does not attempt to prove that there is one H that gets >>>>>>>>>>>>>> the wrong answer for one input. Dennis Bush thinks that Linz >>>>>>>>>>>>>> does do this.
<snip>
That Dennis Bush is too stupid to understand that >>>>>>>>>>>>>>>You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous >>>>>>>>>>>>>>>> evaluation of an infinite set of decider/input pairs and >>>>>>>>>>>>>>>> too stubborn to check with others that he trusts. >>>>>>>>>>>>>>>
No, the conventional HP proof is much simpler than that. >>>>>>>>>>>>>>>
Is it possible for a universal TM halt decider to be >>>>>>>>>>>>>>> constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program >>>>>>>>>>>>>>> that the decider cannot correctly decide, proving that the >>>>>>>>>>>>>>> decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction >>>>>>>>>>> more than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no
contradiction is actually formed.
Not only are you too stupid to see this it is willful stupidity >>>>>>>>>> thus dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly halt >>>>>>>>>> no contradiction is formed.In other words, the function that the HHH you implemented computes >>>>>>>>> is not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of
instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes >>>>>>>>> the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly >>>>>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed >>>>>>>>> directly
That you are too stupid to know that HHH(DD) would report on this >>>>>>>>>> correct basis is yet again your own stupidity.It is you that are too stupid to know that HHH is not a halt >>>>>>>>> decider because it doesn't meet the requirements to be one:
It is common knowledge that the caller of a function is not the >>>>>>>> input to this same function.
Therefore a halt decider is not supposed to report on the behavior >>>>>>>> of its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their inputs... >>>>>
/Flibble
No the DD input is a finite string that that has no behavior and DD()
is an executing process that has behavior.
behavior?
You just contradicted your own arguement.
The problem is the answer isn't based on "the behavior of the input" but >>> "the behavior of what the input represents", which is the program DD
directly executed.
Sorry, you are just showing your ignorance of what you are talking
about.
Indeed he is but alas no matter how many us of tell him that and no
matter
how many times we tell him it will make no difference: Olcott's wilful
obtuseness knows no bounds.
/Flibble
That you do not bother to pay 100% complete
attention is not my mistake.
That DD correctly simulated by and HHH that can
possibly exist cannot reach its own simulated
final halt state is a point that has been:
(a) Dishonestly dodged
(b) Failed to be understood
(c) Lied about
Never has been my mistake for any time in
the last three years.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program
that the decider cannot correctly decide, proving that the
decider is /not/ universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input.
When we eliminate the static data then the
fact that DD() never halts proves that HHH(DD)==0.
On 8/23/2025 4:39 PM, olcott wrote:
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input. Dennis Bush thinks that Linz
does do this.
But you have admitted on the record that this is true by failing
to show where it says otherwise (see below):
You are too
stupid to understand
On 8/23/25 3:53 PM, Richard Heathfield wrote:
On 23/08/2025 18:59, olcott wrote:
On 8/23/2025 12:51 PM, Richard Heathfield wrote:
On 23/08/2025 18:42, olcott wrote:
On 8/23/2025 12:38 PM, Richard Heathfield wrote:
On 23/08/2025 17:27, olcott wrote:DD simulated by HHH is a way to determine the
On 8/23/2025 11:06 AM, Richard Heathfield wrote:
On 23/08/2025 16:36, olcott wrote:
<snip>
Turing machine deciders only compute the mapping
from their inputs...
DD isn't a Turing machine. It's a C function.
And Because HHH is called by DD, HHH /is/ an input.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
Reaching its own simulated return statement isn't the issue.
actual behavior that the actual input actually
specifies.
What about the behaviour of DD(), the C function? You keep
ignoring it in favour of
DD-as-simulated-by-a-function-that-can't-see-75%-of- the-code.
Turing machine
You don't have a TM. DD is a C function.
deciders
You don't have a working decider.
only compute the mapping
...incorrectly...
from their inputs...
You don't concede that DD (the C function) is an input, so you
don't have a meaningful input.
<puerile repetition snipped>
Actually, he HAS conceded that DD is an input, and that as an
input it represents the behavior of DD directly executed, but he
will try to deny that concession.
The problem is he as specified that HHH is a counter example to
the proof, and thus that DD is the "pathological input" of the
proof, which is semantically defined to "Ask the decider to
answer about the direct execution of myself, where I will do the
opposite of what the decider will say".
Since he encodes this statement, in part, with HHH(DD), that call
MUST be DD asking HHH to decide on the direct execution of
itself, namely DD.
This means that when he tries to say that as in input it can't
mean to refer to that direct execution (because Turing Machines
can't do that) he is admitting defeat or that he has a bug in his
code defining DD.
It also means that DD must be an actual PROGRAM (which he will
deny, proving himself a liar) and thus to call HHH, HHH must be
an actual program too, and can't be that "infinite set of
deciders" as you can't call such a thing.
On 8/23/2025 4:06 PM, dbush wrote:
I showed in the Linz proof where only one H is being used. So
unless you show where more than one H or H^ is used, your below
admission stands.
In other words Linz shows that one H gets the
wrong answer on one input and from that he
overgeneralizes to every H on every input?
I saw one person walk across the street
on a red light and from this I can correctly
say that everyone always walks across the
street on a red light?
On 8/23/2025 4:22 PM, dbush wrote:
On 8/23/2025 5:12 PM, olcott wrote:
In other words Linz shows that one H
Which is assumed to be a total halt decider.
gets the
wrong answer on one input
Proving the assumption that a total halt decider exists is false
Very stupid. It only proves that the one H
is not a total halt decider.
It is about an infinite set of decider/input
pairs that match a template.
On 8/23/2025 4:49 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
Turing machine deciders only compute the mapping from their inputs...
Sure and DD is an input to HHH as well as being a caller of HHH.
No the DD input is a finite string that that has no behavior and DD() is
an executing process that has behavior.
On 8/23/2025 4:49 PM, Mr Flibble wrote:
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
Turing machine deciders only compute the mapping from their
inputs...
Sure and DD is an input to HHH as well as being a caller of HHH.
/Flibble
No the DD input is a finite string that that has
no behavior and DD() is an executing process that
has behavior.
On 8/23/2025 4:02 AM, Fred. Zwarts wrote:
Op 22.aug.2025 om 19:04 schreef olcott:
On 8/22/2025 10:02 AM, joes wrote:
Am Fri, 22 Aug 2025 09:36:47 -0500 schrieb olcott:
On 8/22/2025 3:19 AM, joes wrote:No, I was talking about simulating DD with something *different* than
DD, which calls HHH, which aborts after one recursion, can be
simulated
to completion by HHH_n, which aborts after more than one recursion. >>>>> Counter-factual for every HHH that can possibly exist.
simulator that it calls.
HHH and HHH1 have identical source-code according to diff.
HHH(DD)==0 and HHH1(DD)==1 are both correct and the difference
is accounted for in that DD is being simulated in two different
process contexts. HHH1(DD) reaps the benefit of HHH(DD) having
already aborted its simulation. HHH(DD) cannot reap this same
benefit.
That HHH cannot use that benefit is exactly the reason why it fails to
reach the final halt state. It does not change the fact that the input
specifies that final halt state.
HHH cannot benefit from an action that it has not
done yet.
On 8/23/2025 3:49 AM, Fred. Zwarts wrote:
Op 22.aug.2025 om 19:11 schreef olcott:
On 8/22/2025 10:59 AM, Richard Heathfield wrote:
On 22/08/2025 16:18, olcott wrote:
On 8/22/2025 12:12 AM, Richard Heathfield wrote:
On 22/08/2025 04:23, olcott wrote:
<snip>
I have a much deeper philosophical understanding
than people here that only learn by rote can possibly
imagine.
That's a very lofty claim. What persuades you of its truth? Did
you ask an AI how deep your philosophical understanding is? I have >>>>>> no doubt it was very reassuring.
I have been studying the nature of self-referential
paradox for 22 years.
That's nice.
I don't look up what others have said.
Might be an idea to start.
I reverse-engineer the actual truth.
Er... yeah. We've seen how that works out. Stopping isn't halting,
simulation doesn't have to simulate, all that.
Simulation of an input does provide the actual
behavior actually specified by this input as
opposed to and contrast with the behavior of
non-inputs.
Only when it simulates up to the specified final halt state.
When 0 to ∞ instructions of DD are correctly
simulated by HHH this simulated DD never reaches
its own simulated "return" statement final halt state.
In the C code an OOM error would occur first.
On 8/23/2025 4:00 AM, Fred. Zwarts wrote:
Op 22.aug.2025 om 16:36 schreef olcott:
On 8/22/2025 3:19 AM, joes wrote:
Am Thu, 21 Aug 2025 17:12:27 -0500 schrieb olcott:
Its easy to see that DD correctly simulated by any HHH that can exist >>>>> cannot possibly reach its own "return" statement final halt stateDD, which calls HHH, which aborts after one recursion, can be simulated >>>> to completion by HHH_n, which aborts after more than one recursion.
in the
same way that it can be seen that driving into any brick wall at
100 MPH
will not end well.
Counter-factual for every HHH that can possibly exist.
_DD()
[00002162] 55 push ebp
[00002163] 8bec mov ebp,esp
[00002165] 51 push ecx
[00002166] 6862210000 push 00002162 // push DD
[0000216b] e862f4ffff call 000015d2 // call HHH
[00002170] 83c404 add esp,+04
[00002173] 8945fc mov [ebp-04],eax
[00002176] 837dfc00 cmp dword [ebp-04],+00
[0000217a] 7402 jz 0000217e
[0000217c] ebfe jmp 0000217c
[0000217e] 8b45fc mov eax,[ebp-04]
[00002181] 8be5 mov esp,ebp
[00002183] 5d pop ebp
[00002184] c3 et
Size in bytes:(0035) [00002184]
When N is a natural number and we ignore OOM errors
then when N instructions of DD are correctly emulated
by some HHH, none of these correctly emulated DD
instructions reach past their own machine address
0000216b.
But a correct simulation of N instructions is not yet a correct
simulation of the whole program.
Requiring a non terminating input to be
simulated to its non-existent completion
is stupid.
Other simulators prove that more than N steps are needed for this
particular input and that the final halt state for this input is
specified.
Further HHH fails to prove, when it aborts, that further simulation
would not reach the final halt state specified in this input, because
it ignores the conditional branch instructions.
That other inputs are also not correctly simulated, is not a proof
that this input was simulated correctly.
When HHH aborts its simulation of DD zero instructions
of any level of simulation are emulated thus there is
no stack unwinding.
On 8/23/2025 3:55 AM, Fred. Zwarts wrote:But you change the input. In your infinite set each decider has a
Op 22.aug.2025 om 22:36 schreef olcott:
On 8/22/2025 3:20 PM, Kaz Kylheku wrote:
On 2025-08-22, dbush <dbush.mobile@gmail.com> wrote:
On 8/22/2025 3:45 PM, olcott wrote:
On 8/22/2025 2:26 PM, dbush wrote:Which means you're changing the input.
If neither HHH nor HHH1 have access to the execution
trace data then HHH(DD), DD(), HHH1(DD) never stop
running
Changing the input is not allowed.
Statements like this only confuse Peter.
Changing the input is of course allowed, as long as you don't do
anything intellectually wrong: i.e. any conclusions that emerge from
your calculation are correct statements about the original input.
Consider a Turing Machine. The input is the tape. It changes
the tape!
Because a Turing Machine changes the tape, Olcott thinks that
his "x86 UTM" can likewise treat every bit in the system as
a symbol on a tape and flip it as it sees fit.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
Simultaneously evaluates an infinite set of
decider/input pairs, thus changing the input
is required otherwise the proof only shows
that there is one decider/input pair that gets
the wrong answer.
But by changing the input you only prove that each of them fails for
that particular input.
That *is* the Linz proof. No inputs are changed
that Linz did not change.
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program that
the decider cannot correctly decide, proving that the decider is / >>>>>> not/ universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input. Dennis Bush thinks that Linz
does do this.
But you have admitted on the record that
Says the person that doesn't understand proof by contradiction more
than 50 years after he learned it.
I showed in the Linz proof where only one H is being used. So unless
you show where more than one H or H^ is used, your below admission
stands.
In other words Linz shows that one H gets the
wrong answer on one input and from that he
overgeneralizes to every H on every input?
I saw one person walk across the street
on a red light and from this I can correctly
say that everyone always walks across the
street on a red light?
On 8/23/2025 6:33 PM, Mr Flibble BSc (Hons) wrote:
On Sat, 23 Aug 2025 18:17:32 -0500, olcott wrote:
On 8/23/2025 6:09 PM, Mr Flibble BSc (Hons) wrote:
On Sat, 23 Aug 2025 19:06:20 -0400, Richard Damon wrote:
On 8/23/25 5:56 PM, olcott wrote:
On 8/23/2025 4:49 PM, Mr Flibble wrote:So, how do you answer about the behavior of a string that doesn't have >>>>> behavior?
On Sat, 23 Aug 2025 16:48:14 -0500, olcott wrote:
On 8/23/2025 4:39 PM, dbush wrote:
On 8/23/2025 5:36 PM, olcott wrote:
On 8/23/2025 4:29 PM, dbush wrote:
On 8/23/2025 5:24 PM, olcott wrote:It is common knowledge that HHH is supposed to compute the >>>>>>>>>> mapping from its inputs.
On 8/23/2025 4:06 PM, dbush wrote:
On 8/23/2025 5:00 PM, olcott wrote:It is not that I don't know proof by contradiction.
On 8/23/2025 3:52 PM, dbush wrote:
On 8/23/2025 4:39 PM, olcott wrote:You are too stupid to understand the HP proofs.
On 8/23/2025 3:14 PM, Richard Heathfield wrote: >>>>>>>>>>>>>>>>> On 23/08/2025 19:11, olcott wrote:But you have admitted on the record that
Linz does not attempt to prove that there is one H that >>>>>>>>>>>>>>>> gets the wrong answer for one input. Dennis Bush thinks >>>>>>>>>>>>>>>> that Linz does do this.
<snip>
That Dennis Bush is too stupid to understand that >>>>>>>>>>>>>>>>>You are in no position to call anyone stupid. >>>>>>>>>>>>>>>>>
the conventional HP proofs involve the simultaneous >>>>>>>>>>>>>>>>>> evaluation of an infinite set of decider/input pairs and >>>>>>>>>>>>>>>>>> too stubborn to check with others that he trusts. >>>>>>>>>>>>>>>>>
No, the conventional HP proof is much simpler than that. >>>>>>>>>>>>>>>>>
Is it possible for a universal TM halt decider to be >>>>>>>>>>>>>>>>> constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a >>>>>>>>>>>>>>>>> program that the decider cannot correctly decide, proving >>>>>>>>>>>>>>>>> that the decider is / not/ universal.
Assumption A is shown to be false, QED.
Says the person that doesn't understand proof by contradiction >>>>>>>>>>>>> more than 50 years after he learned it.
22 years of posts by you conclusively proves otherwise.
It is that I am not too stupid to not notice when no
contradiction is actually formed.
Not only are you too stupid to see this it is willful stupidity >>>>>>>>>>>> thus dishonestly.
Projection.
When HHH reports that DD correctly simulated cannot possibly >>>>>>>>>>>> halt no contradiction is formed.In other words, the function that the HHH you implemented >>>>>>>>>>> computes is not the halting function:
Given any algorithm (i.e. a fixed immutable sequence of
instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that >>>>>>>>>>> computes the following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed >>>>>>>>>>> directly (<X>,Y) maps to 0 if and only if X(Y) does not halt >>>>>>>>>>> when executed directly
That you are too stupid to know that HHH(DD) would report on >>>>>>>>>>>> this correct basis is yet again your own stupidity.It is you that are too stupid to know that HHH is not a halt >>>>>>>>>>> decider because it doesn't meet the requirements to be one: >>>>>>>>>>>
It is common knowledge that the caller of a function is not the >>>>>>>>>> input to this same function.
Therefore a halt decider is not supposed to report on the
behavior of its caller is derived from common knowledge.
In other words, the proof is wrong because
It ignores the axiom that
Turing machine deciders only compute the mapping from their
inputs...
Sure and DD is an input to HHH as well as being a caller of HHH. >>>>>>>
/Flibble
No the DD input is a finite string that that has no behavior and DD() >>>>>> is an executing process that has behavior.
You just contradicted your own arguement.
The problem is the answer isn't based on "the behavior of the input" >>>>> but "the behavior of what the input represents", which is the program >>>>> DD directly executed.
Sorry, you are just showing your ignorance of what you are talking
about.
Indeed he is but alas no matter how many us of tell him that and no
matter how many times we tell him it will make no difference: Olcott's >>>> wilful obtuseness knows no bounds.
/Flibble
That you do not bother to pay 100% complete attention is not my mistake. >>>
That DD correctly simulated by and HHH that can possibly exist cannot
reach its own simulated final halt state is a point that has been:
(a) Dishonestly dodged (b) Failed to be understood (c) Lied about Never
has been my mistake for any time in the last three years.
Infinite recursion is a property of your approach; a halt decider that
just used static analysis rather than simulation could determine that a
nested call to the halt decider is equivalent to infinite recursion and
like your HHH make a decision of non-halting but nevertheless it still
doesn't matter what halt decision the halt decider makes because the
ultimate caller of the decider (equivalent to the decider's input)
will do
the opposite causing a logical contradiction confirming that the extant
Halting Problem proofs are correct.
/Flibble
It is only supposed to report on the behavior that the input to HHH(DD) specifies as measured by DD correctly simulated by HHH. Everyone one
else has gotten the computer science of this incorrectly.
On 8/24/2025 12:22 AM, Richard Heathfield wrote:
On 23/08/2025 23:39, olcott wrote:
<snip>
It is about an infinite set of decider/input
pairs that match a template.
No, it's about an empty set, and therefore no such pair can exist.
It is not about one decider/input pair.
On 8/23/2025 11:54 PM, Richard Heathfield wrote:
On 23/08/2025 22:04, olcott wrote:
You are too
stupid to understand
is not an argument.
It is an assessment.
On 8/24/2025 12:02 AM, Richard Heathfield wrote:
On 23/08/2025 22:12, olcott wrote:
On 8/23/2025 4:06 PM, dbush wrote:
<snip>
I showed in the Linz proof where only one H is being used.
So unless you show where more than one H or H^ is used, your
below admission stands.
In other words Linz shows that one H gets the
wrong answer on one input and from that he
overgeneralizes to every H on every input?
No, what he shows is that no universal decider can exist
(because if one could it would give rise to a contradiction).
I think that you are getting the gist of this correctly.
I forget who was getting it wrong, Dennis Bush?
On 8/23/2025 11:44 PM, Richard Heathfield wrote:
On 23/08/2025 21:40, olcott wrote:No it actually never halts.
When we eliminate the static data then the
fact that DD() never halts proves that HHH(DD)==0.
...and DD promptly halts. Odd, that.
On 8/23/2025 11:43 PM, Richard Heathfield wrote:
On 23/08/2025 21:39, olcott wrote:
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be
constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program
that the decider cannot correctly decide, proving that the
decider is /not/ universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input.
Who said anything about even one? The conventional proof of the
undecidability of the Halting Problem proves that 0 universal
halt deciders exist. There are therefore 0 candidates for
inputs, because there are no deciders to be candidates /for/. 1
simply doesn't enter into it.
Dennis Bush thinks that when Linz proves that one H
does not get the right answer on one input that this
proves that no universal decider exists.
On 8/24/2025 12:22 AM, Richard Heathfield wrote:
On 23/08/2025 23:39, olcott wrote:
<snip>
It is about an infinite set of decider/input
pairs that match a template.
No, it's about an empty set, and therefore no such pair can exist.
It is not about one decider/input pair.
On 8/23/2025 11:43 PM, Richard Heathfield wrote:
On 23/08/2025 21:39, olcott wrote:
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program that the
decider cannot correctly decide, proving that the decider is /not/
universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input.
Who said anything about even one? The conventional proof of the
undecidability of the Halting Problem proves that 0 universal halt
deciders exist. There are therefore 0 candidates for inputs, because
there are no deciders to be candidates /for/. 1 simply doesn't enter
into it.
Dennis Bush thinks that when Linz proves that one H
does not get the right answer on one input that this
proves that no universal decider exists.
On 8/23/2025 11:54 PM, Richard Heathfield wrote:
On 23/08/2025 22:04, olcott wrote:
You are too
stupid to understand
is not an argument.
It is an assessment.
On 8/23/2025 11:44 PM, Richard Heathfield wrote:
On 23/08/2025 21:40, olcott wrote:No it actually never halts.
When we eliminate the static data then the
fact that DD() never halts proves that HHH(DD)==0.
...and DD promptly halts. Odd, that.
On 8/25/2025 1:00 AM, Richard Heathfield wrote:
On 25/08/2025 05:54, olcott wrote:
I forget who was getting it wrong, Dennis Bush?
Nobody posts here under that name, but if you're talking about
dbush (which seems likely), he seems to me to have a perfectly
adequate grasp of the undecidability proof.
He does not.
On 8/25/2025 1:07 AM, Richard Heathfield wrote:
On 25/08/2025 05:55, olcott wrote:
On 8/23/2025 11:54 PM, Richard Heathfield wrote:
On 23/08/2025 22:04, olcott wrote:
You are too
stupid to understand
is not an argument.
It is an assessment.
You have assessed a number of people that way in the past
couple of months. It may have escaped your notice, but most of
us are, most of the time, polite enough not to assess back.
Rudeness will not help you to persuade anyone. I acknowledge
that you are not the only one here foolish enough to use such
insults, but you would do better to leave unduly frequent
incivility in the hands of your more boorish detractors.
When people post foolish nonsense in a lame
attempt to denigrate my work I must point it out.
I also try to allocate their error into:
(a) Damned lie.
(b) Lack of sufficient technical competence.
(c) Common false assumption.
On 8/25/2025 1:21 AM, Richard Heathfield wrote:
By analyzing every element of the set of
Ĥ.embedded_H / input pairs by this template:
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
Dennis Bush believes that Linz analyzes a
single decider/input pair not every element
of an infinite set of decider/input pairs.
On 8/25/2025 1:21 AM, Richard Heathfield wrote:
On 25/08/2025 06:01, olcott wrote:
On 8/23/2025 11:43 PM, Richard Heathfield wrote:
On 23/08/2025 21:39, olcott wrote:
On 8/23/2025 3:14 PM, Richard Heathfield wrote:
On 23/08/2025 19:11, olcott wrote:
<snip>
That Dennis Bush is too stupid to understand that
You are in no position to call anyone stupid.
the conventional HP proofs involve the simultaneous
evaluation of an infinite set of decider/input pairs
and too stubborn to check with others that he trusts.
No, the conventional HP proof is much simpler than that.
Is it possible for a universal TM halt decider to be constructed?
Assumption A: Let us assume it is possible.
We can now use the universal decider to construct a program that
the decider cannot correctly decide, proving that the decider is / >>>>>> not/ universal.
Assumption A is shown to be false, QED.
Linz does not attempt to prove that there
is one H that gets the wrong answer for
one input.
Who said anything about even one? The conventional proof of the
undecidability of the Halting Problem proves that 0 universal halt
deciders exist. There are therefore 0 candidates for inputs, because
there are no deciders to be candidates /for/. 1 simply doesn't enter
into it.
Dennis Bush thinks that when Linz proves that one H
What H? There is no H.
does not get the right answer on one input that this
proves that no universal decider exists.
That's not how Linz proves what he proves. He *assumes* that a
universal decider exists. Having done so, he correctly proves that his
assumption is false.
By analyzing every element of the set of
Ĥ.embedded_H / input pairs by this template:
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
Dennis Bush believes that Linz analyzes a
single decider/input pair not every element
of an infinite set of decider/input pairs.
On 8/25/2025 1:07 AM, Richard Heathfield wrote:
On 25/08/2025 05:55, olcott wrote:
On 8/23/2025 11:54 PM, Richard Heathfield wrote:
On 23/08/2025 22:04, olcott wrote:
You are too
stupid to understand
is not an argument.
It is an assessment.
You have assessed a number of people that way in the past couple of
months. It may have escaped your notice, but most of us are, most of
the time, polite enough not to assess back.
Rudeness will not help you to persuade anyone. I acknowledge that you
are not the only one here foolish enough to use such insults, but you
would do better to leave unduly frequent incivility in the hands of
your more boorish detractors.
When people post foolish nonsense in a lame
attempt to denigrate my work I must point it out.
I also try to allocate their error into:
(a) Damned lie.
(b) Lack of sufficient technical competence.
(c) Common false assumption.
On 8/25/2025 10:29 AM, Richard Heathfield wrote:
On 25/08/2025 16:19, olcott wrote:
On 8/25/2025 1:21 AM, Richard Heathfield wrote:
<snip>
By analyzing every element of the set of
Ĥ.embedded_H / input pairs by this template:
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
Dennis Bush believes that Linz analyzes a
single decider/input pair not every element
of an infinite set of decider/input pairs.
No, he doesn't. I'm sure Linz isn't that stupid, and I'm sure Dennis
Bush or dbush or whoever it is shares my opinion.
Linz is much cleverer. He listened to Turing.
Linz derived the most brilliant proof because it
can be analyzed in terms of specific state transitions.
Hos only mistake was copying the mistake of all others
that a halt decider is required to report on anything
besides the actual behavior that the actual input
actually specifies as measured by the behavior of DD
correctly simulated by HHH.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 00:03:05 |
| Calls: | 10,385 |
| Calls today: | 2 |
| Files: | 14,057 |
| Messages: | 6,416,566 |