On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 7/5/2025 2:07 PM, Alan Mackenzie wrote:
You lie. You don't have a proof. Many people in this group have pointed
out lots of errors in various versions of your purported proof, which you
just ignore. The section in Professor Linz's book you used to be so fond
of citing will contain plenty of details, if only you would take the >>>>>> trouble to understand it (assuming you're capable of such understanding).
I have addressed ....
Meaningless pompous word.
.... all of those details that you make sure to ignore so that you can >>>>> baselessly claim that I am wrong.
I vaguely remember rolling my eyes at your hopeless lack of
understanding. It was like watching a 7 year old trying to do calculus. >>>> The basic understanding was simply not there. Years later, it's still >>>> not there.
And yes, you are wrong. The proofs of the halting theorem which involve >>>> constructing programs which purported halting deciders cannot decide
correctly are correct.
Yet you cannot point to even one mistake because there are none.
That's what I'm saying. Those proofs of the halting theorem are free
from mistakes.
More to the point, it is YOU who cannot point to any mistakes in them.
They are valid proofs. Your work, if it contradicts those proofs (which
isn't at all clear) can thus be dismissed without further consideration.
There cannot possibly be *AN ACTUAL INPUT* that does the
opposite of whatever its decider decides. All of the examples
of this have never been *ACTUAL INPUTS*
That's so sloppily worded, it could mean almost anything.
The standard halting problem proof cannot even be constructed.
It has been constructed, and is valid. But one would normally talk about
formulating a proof, rather than constructing one.
[ .... ]
No Turing machine can possibly take another directly executing
Turing machine as in input, thus removing these from the
domain of every halt decider.
And that, too.
*Thus the requirement that HHH report on the behavior*
*of the directly executed DD has always been bogus*
And that makes your hat trick.
Turing machine partial halt deciders compute the mapping
from their actual inputs to the actual behavior that these
inputs specify.
And a fourth. There's some semblance of truth in there, but it's very >>>> confused.
It is not at all confused. I know exactly what it means.
It's very confused to everybody but you, then.
Sloppy wording is your technique to get people to go down to your level >>>> of discussion. That involves many posts trying just to tie you down to >>>> specific word meanings, and is very tiresome and unrewarding. I decline >>>> to get involved any further.
*Yet as I claimed you found no actual mistake*
I've found plenty of actual mistakes. I was a software developer by
profession.
Let me tell you the punchline so that you can
see why I said those things.
Despite what I said last post, I will actually go to the trouble of
analysing your sloppy expression.
Because directly executed Turing machines cannot
possibly be inputs to Turing machine deciders this
makes them outside of the domain of these deciders.
It's entirely unclear what a "directly executed Turing machine" is. Most
of the time turing machines are theoretical constructs used for proving
theorems. They can be executed, but rarely are.
It's unclear what you mean by a turing machine being an input to a turing
machine. Read up about universal turing machines to get a bit of
background.
When a partial halt decider is required to report
on the direct execution of a machine this requirement
is bogus.
See above. That paragraph is meaningless.
This means that the behavior of DD() is none of the damn
business of HHH, thus does not contradict HHH(DD)==0.
*If you disagree this only proves that you do not understand*
It's fully obscure what DD() and HHH mean, and thus impossible to
affirm or contradict the meaningless "HHH(DD)==0".
HHH(DD) does correctly detect that DD simulated by HHH
according to the semantics pf the C programming language
cannot possibly reach its own "return"statement final
halt state.
See above. By the way, people concerned with computation theory use
turing machines, which are well-defined, simple, and powerful. They lack
the complexity, ambiguity, and unsuitability for theoretical work of real
world programming languages like C.
*If you disagree this only proves that you do not understand*
Any mindless idiot can disagree. Showing an error and proving
that it is an actual mistake requires much more than this.
Indeed. All you have done is disagree with one of the proofs of the
halting theorem. You have yet to show an error in it. That will be
difficult, because there aren't any.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
<*Halting Problem Proof ERROR*>
Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.
On 7/19/2025 3:05 AM, Mikko wrote:
On 2025-07-17 14:44:23 +0000, olcott said:
On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 7/5/2025 2:07 PM, Alan Mackenzie wrote:
You lie. You don't have a proof. Many people in this group have pointed
out lots of errors in various versions of your purported proof, which you
just ignore. The section in Professor Linz's book you used to be so fond
of citing will contain plenty of details, if only you would take the >>>>>>>> trouble to understand it (assuming you're capable of such understanding).
I have addressed ....
Meaningless pompous word.
.... all of those details that you make sure to ignore so that you can >>>>>>> baselessly claim that I am wrong.
I vaguely remember rolling my eyes at your hopeless lack of
understanding. It was like watching a 7 year old trying to do calculus.
The basic understanding was simply not there. Years later, it's still >>>>>> not there.
And yes, you are wrong. The proofs of the halting theorem which involve
constructing programs which purported halting deciders cannot decide >>>>>> correctly are correct.
Yet you cannot point to even one mistake because there are none.
That's what I'm saying. Those proofs of the halting theorem are free >>>> from mistakes.
More to the point, it is YOU who cannot point to any mistakes in them. >>>> They are valid proofs. Your work, if it contradicts those proofs (which >>>> isn't at all clear) can thus be dismissed without further consideration. >>>>
There cannot possibly be *AN ACTUAL INPUT* that does the
opposite of whatever its decider decides. All of the examples
of this have never been *ACTUAL INPUTS*
That's so sloppily worded, it could mean almost anything.
The standard halting problem proof cannot even be constructed.
It has been constructed, and is valid. But one would normally talk about >>>> formulating a proof, rather than constructing one.
[ .... ]
No Turing machine can possibly take another directly executing
Turing machine as in input, thus removing these from the
domain of every halt decider.
And that, too.
*Thus the requirement that HHH report on the behavior*
*of the directly executed DD has always been bogus*
And that makes your hat trick.
Turing machine partial halt deciders compute the mapping
from their actual inputs to the actual behavior that these
inputs specify.
And a fourth. There's some semblance of truth in there, but it's very >>>>>> confused.
It is not at all confused. I know exactly what it means.
It's very confused to everybody but you, then.
Sloppy wording is your technique to get people to go down to your level >>>>>> of discussion. That involves many posts trying just to tie you down to >>>>>> specific word meanings, and is very tiresome and unrewarding. I decline
to get involved any further.
*Yet as I claimed you found no actual mistake*
I've found plenty of actual mistakes. I was a software developer by
profession.
Let me tell you the punchline so that you can
see why I said those things.
Despite what I said last post, I will actually go to the trouble of
analysing your sloppy expression.
Because directly executed Turing machines cannot
possibly be inputs to Turing machine deciders this
makes them outside of the domain of these deciders.
It's entirely unclear what a "directly executed Turing machine" is. Most >>>> of the time turing machines are theoretical constructs used for proving >>>> theorems. They can be executed, but rarely are.
It's unclear what you mean by a turing machine being an input to a turing >>>> machine. Read up about universal turing machines to get a bit of
background.
When a partial halt decider is required to report
on the direct execution of a machine this requirement
is bogus.
See above. That paragraph is meaningless.
This means that the behavior of DD() is none of the damn
business of HHH, thus does not contradict HHH(DD)==0.
*If you disagree this only proves that you do not understand*
It's fully obscure what DD() and HHH mean, and thus impossible to
affirm or contradict the meaningless "HHH(DD)==0".
HHH(DD) does correctly detect that DD simulated by HHH
according to the semantics pf the C programming language
cannot possibly reach its own "return"statement final
halt state.
See above. By the way, people concerned with computation theory use
turing machines, which are well-defined, simple, and powerful. They lack >>>> the complexity, ambiguity, and unsuitability for theoretical work of real >>>> world programming languages like C.
*If you disagree this only proves that you do not understand*
Any mindless idiot can disagree. Showing an error and proving
that it is an actual mistake requires much more than this.
Indeed. All you have done is disagree with one of the proofs of the
halting theorem. You have yet to show an error in it. That will be >>>> difficult, because there aren't any.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
This means nothing as long as symbols are undefined.
They are defined on the link provided on the next line.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
<*Halting Problem Proof ERROR*>
Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.
It is not clear what is the subject of the sentence. It makes a big
difference who or what requires. Some requirements are essential to
the topic but others may be irrelevant or even bogus.
This notation refers to Turing Machine: Ĥ
This notation refers to TM description: ⟨Ĥ⟩
The complete context is provided in the original proof https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
*Here is the corrected proof*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
Ĥ.embedded_H correctly transitions to Ĥ.qn.
On 7/20/2025 3:39 AM, Mikko wrote:
On 2025-07-19 15:11:21 +0000, olcott said:
On 7/19/2025 3:05 AM, Mikko wrote:
On 2025-07-17 14:44:23 +0000, olcott said:
On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 7/5/2025 2:07 PM, Alan Mackenzie wrote:
You lie. You don't have a proof. Many people in this group have pointed
out lots of errors in various versions of your purported proof, which you
just ignore. The section in Professor Linz's book you used to be so fond
of citing will contain plenty of details, if only you would take the >>>>>>>>>> trouble to understand it (assuming you're capable of such understanding).
I have addressed ....
Meaningless pompous word.
.... all of those details that you make sure to ignore so that you can
baselessly claim that I am wrong.
I vaguely remember rolling my eyes at your hopeless lack of
understanding. It was like watching a 7 year old trying to do calculus.
The basic understanding was simply not there. Years later, it's still
not there.
And yes, you are wrong. The proofs of the halting theorem which involve
constructing programs which purported halting deciders cannot decide >>>>>>>> correctly are correct.
Yet you cannot point to even one mistake because there are none.
That's what I'm saying. Those proofs of the halting theorem are free >>>>>> from mistakes.
More to the point, it is YOU who cannot point to any mistakes in them. >>>>>> They are valid proofs. Your work, if it contradicts those proofs (which
isn't at all clear) can thus be dismissed without further consideration. >>>>>>
There cannot possibly be *AN ACTUAL INPUT* that does the
opposite of whatever its decider decides. All of the examples >>>>>>>>> of this have never been *ACTUAL INPUTS*
That's so sloppily worded, it could mean almost anything.
The standard halting problem proof cannot even be constructed.
It has been constructed, and is valid. But one would normally talk about
formulating a proof, rather than constructing one.
[ .... ]
No Turing machine can possibly take another directly executing >>>>>>>>> Turing machine as in input, thus removing these from the
domain of every halt decider.
And that, too.
*Thus the requirement that HHH report on the behavior*
*of the directly executed DD has always been bogus*
And that makes your hat trick.
Turing machine partial halt deciders compute the mapping
from their actual inputs to the actual behavior that these
inputs specify.
And a fourth. There's some semblance of truth in there, but it's very
confused.
It is not at all confused. I know exactly what it means.
It's very confused to everybody but you, then.
Sloppy wording is your technique to get people to go down to your level
of discussion. That involves many posts trying just to tie you down to
specific word meanings, and is very tiresome and unrewarding. I decline
to get involved any further.
*Yet as I claimed you found no actual mistake*
I've found plenty of actual mistakes. I was a software developer by >>>>>> profession.
Let me tell you the punchline so that you can
see why I said those things.
Despite what I said last post, I will actually go to the trouble of >>>>>> analysing your sloppy expression.
Because directly executed Turing machines cannot
possibly be inputs to Turing machine deciders this
makes them outside of the domain of these deciders.
It's entirely unclear what a "directly executed Turing machine" is. Most
of the time turing machines are theoretical constructs used for proving >>>>>> theorems. They can be executed, but rarely are.
It's unclear what you mean by a turing machine being an input to a turing
machine. Read up about universal turing machines to get a bit of >>>>>> background.
When a partial halt decider is required to report
on the direct execution of a machine this requirement
is bogus.
See above. That paragraph is meaningless.
This means that the behavior of DD() is none of the damn
business of HHH, thus does not contradict HHH(DD)==0.
*If you disagree this only proves that you do not understand*
It's fully obscure what DD() and HHH mean, and thus impossible to
affirm or contradict the meaningless "HHH(DD)==0".
HHH(DD) does correctly detect that DD simulated by HHH
according to the semantics pf the C programming language
cannot possibly reach its own "return"statement final
halt state.
See above. By the way, people concerned with computation theory use >>>>>> turing machines, which are well-defined, simple, and powerful. They lack
the complexity, ambiguity, and unsuitability for theoretical work of real
world programming languages like C.
*If you disagree this only proves that you do not understand*
Any mindless idiot can disagree. Showing an error and proving
that it is an actual mistake requires much more than this.
Indeed. All you have done is disagree with one of the proofs of the >>>>>> halting theorem. You have yet to show an error in it. That will be >>>>>> difficult, because there aren't any.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
This means nothing as long as symbols are undefined.
They are defined on the link provided on the next line.
That was not said in the quoted message, and some of the symbols
are not defined there.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
<*Halting Problem Proof ERROR*>
Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.
It is not clear what is the subject of the sentence. It makes a big
difference who or what requires. Some requirements are essential to
the topic but others may be irrelevant or even bogus.
<ChatGPT>
Misrepresentation of Input:
The standard proof assumes a decider
H(M,x) that determines whether machine
M halts on input x.
But this formulation is flawed, because:
Turing machines can only process finite
encodings (e.g. ⟨M⟩), not executable entities
like M.
So the valid formulation must be
H(⟨M⟩,x), where ⟨M⟩ is a string.
</ChatGPT>
This notation refers to Turing Machine: Ĥ
This notation refers to TM description: ⟨Ĥ⟩
The complete context is provided in the original proof
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
*Here is the corrected proof*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
Ĥ.embedded_H correctly transitions to Ĥ.qn.
The question about the missing subject remains unanswered. Apparently
you don't know what you were talking about.
The key subject to me is this:
How does Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to Ĥ.qn correctly?
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation until
embedded_H sees the repeating pattern and transitions to Ĥ.qn.
On 7/21/2025 4:28 AM, Mikko wrote:
On 2025-07-20 15:02:30 +0000, olcott said:
On 7/20/2025 3:39 AM, Mikko wrote:
On 2025-07-19 15:11:21 +0000, olcott said:
On 7/19/2025 3:05 AM, Mikko wrote:
On 2025-07-17 14:44:23 +0000, olcott said:
On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/6/2025 5:16 AM, Alan Mackenzie wrote:That's what I'm saying. Those proofs of the halting theorem are free >>>>>>>> from mistakes.
olcott <polcott333@gmail.com> wrote:
On 7/5/2025 2:07 PM, Alan Mackenzie wrote:
You lie. You don't have a proof. Many people in this group have pointed
out lots of errors in various versions of your purported proof, which you
just ignore. The section in Professor Linz's book you used to be so fond
of citing will contain plenty of details, if only you would take the
trouble to understand it (assuming you're capable of such understanding).
I have addressed ....
Meaningless pompous word.
.... all of those details that you make sure to ignore so that you can
baselessly claim that I am wrong.
I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>> understanding. It was like watching a 7 year old trying to do calculus.
The basic understanding was simply not there. Years later, it's still
not there.
And yes, you are wrong. The proofs of the halting theorem which involve
constructing programs which purported halting deciders cannot decide >>>>>>>>>> correctly are correct.
Yet you cannot point to even one mistake because there are none. >>>>>>>>
More to the point, it is YOU who cannot point to any mistakes in them. >>>>>>>> They are valid proofs. Your work, if it contradicts those proofs (which
isn't at all clear) can thus be dismissed without further consideration.
It has been constructed, and is valid. But one would normally talk aboutThere cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>> opposite of whatever its decider decides. All of the examples >>>>>>>>>>> of this have never been *ACTUAL INPUTS*
That's so sloppily worded, it could mean almost anything.
The standard halting problem proof cannot even be constructed. >>>>>>>>
formulating a proof, rather than constructing one.
[ .... ]
No Turing machine can possibly take another directly executing >>>>>>>>>>> Turing machine as in input, thus removing these from the >>>>>>>>>>> domain of every halt decider.
And that, too.
*Thus the requirement that HHH report on the behavior*
*of the directly executed DD has always been bogus*
And that makes your hat trick.
Turing machine partial halt deciders compute the mapping >>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>> inputs specify.
And a fourth. There's some semblance of truth in there, but it's very
confused.
It is not at all confused. I know exactly what it means.
It's very confused to everybody but you, then.
Sloppy wording is your technique to get people to go down to your level
of discussion. That involves many posts trying just to tie you down to
specific word meanings, and is very tiresome and unrewarding. I decline
to get involved any further.
*Yet as I claimed you found no actual mistake*
I've found plenty of actual mistakes. I was a software developer by >>>>>>>> profession.
Let me tell you the punchline so that you can
see why I said those things.
Despite what I said last post, I will actually go to the trouble of >>>>>>>> analysing your sloppy expression.
Because directly executed Turing machines cannot
possibly be inputs to Turing machine deciders this
makes them outside of the domain of these deciders.
It's entirely unclear what a "directly executed Turing machine" is. Most
of the time turing machines are theoretical constructs used for proving
theorems. They can be executed, but rarely are.
It's unclear what you mean by a turing machine being an input to a turing
machine. Read up about universal turing machines to get a bit of >>>>>>>> background.
When a partial halt decider is required to report
on the direct execution of a machine this requirement
is bogus.
See above. That paragraph is meaningless.
This means that the behavior of DD() is none of the damnIt's fully obscure what DD() and HHH mean, and thus impossible to >>>>>>>> affirm or contradict the meaningless "HHH(DD)==0".
business of HHH, thus does not contradict HHH(DD)==0.
*If you disagree this only proves that you do not understand* >>>>>>>>
HHH(DD) does correctly detect that DD simulated by HHH
according to the semantics pf the C programming language
cannot possibly reach its own "return"statement final
halt state.
See above. By the way, people concerned with computation theory use >>>>>>>> turing machines, which are well-defined, simple, and powerful. They lack
the complexity, ambiguity, and unsuitability for theoretical work of real
world programming languages like C.
*If you disagree this only proves that you do not understand* >>>>>>>>
Any mindless idiot can disagree. Showing an error and proving >>>>>>>>> that it is an actual mistake requires much more than this.
Indeed. All you have done is disagree with one of the proofs of the >>>>>>>> halting theorem. You have yet to show an error in it. That will be >>>>>>>> difficult, because there aren't any.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
This means nothing as long as symbols are undefined.
They are defined on the link provided on the next line.
That was not said in the quoted message, and some of the symbols
are not defined there.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
<*Halting Problem Proof ERROR*>
Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.
It is not clear what is the subject of the sentence. It makes a big >>>>>> difference who or what requires. Some requirements are essential to >>>>>> the topic but others may be irrelevant or even bogus.
<ChatGPT>
Misrepresentation of Input:
The standard proof assumes a decider
H(M,x) that determines whether machine
M halts on input x.
But this formulation is flawed, because:
Turing machines can only process finite
encodings (e.g. ⟨M⟩), not executable entities
like M.
So the valid formulation must be
H(⟨M⟩,x), where ⟨M⟩ is a string.
</ChatGPT>
This notation refers to Turing Machine: Ĥ
This notation refers to TM description: ⟨Ĥ⟩
The complete context is provided in the original proof
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
*Here is the corrected proof*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>> reach its simulated final halt state of ⟨Ĥ.qn⟩.
Ĥ.embedded_H correctly transitions to Ĥ.qn.
The question about the missing subject remains unanswered. Apparently
you don't know what you were talking about.
The key subject to me is this:
How does Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to Ĥ.qn correctly?
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation until
embedded_H sees the repeating pattern and transitions to Ĥ.qn.
None of which is relevant to the point what is not a garamamtical
sentence cannot be true.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
*The above incorrect proof is corrected below*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
On 7/22/2025 5:58 AM, Mikko wrote:
On 2025-07-21 14:04:38 +0000, olcott said:
On 7/21/2025 4:28 AM, Mikko wrote:
On 2025-07-20 15:02:30 +0000, olcott said:
On 7/20/2025 3:39 AM, Mikko wrote:
On 2025-07-19 15:11:21 +0000, olcott said:
On 7/19/2025 3:05 AM, Mikko wrote:
On 2025-07-17 14:44:23 +0000, olcott said:
On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/6/2025 5:16 AM, Alan Mackenzie wrote:That's what I'm saying. Those proofs of the halting theorem >>>>>>>>>> are free
olcott <polcott333@gmail.com> wrote:
On 7/5/2025 2:07 PM, Alan Mackenzie wrote:
You lie. You don't have a proof. Many people in this >>>>>>>>>>>>>> group have pointed
out lots of errors in various versions of your purported >>>>>>>>>>>>>> proof, which you
just ignore. The section in Professor Linz's book you >>>>>>>>>>>>>> used to be so fond
of citing will contain plenty of details, if only you >>>>>>>>>>>>>> would take the
trouble to understand it (assuming you're capable of such >>>>>>>>>>>>>> understanding).
I have addressed ....
Meaningless pompous word.
.... all of those details that you make sure to ignore so >>>>>>>>>>>>> that you can
baselessly claim that I am wrong.
I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>>>> understanding. It was like watching a 7 year old trying to >>>>>>>>>>>> do calculus.
The basic understanding was simply not there. Years later, >>>>>>>>>>>> it's still
not there.
And yes, you are wrong. The proofs of the halting theorem >>>>>>>>>>>> which involve
constructing programs which purported halting deciders >>>>>>>>>>>> cannot decide
correctly are correct.
Yet you cannot point to even one mistake because there are none. >>>>>>>>>>
from mistakes.
More to the point, it is YOU who cannot point to any mistakes >>>>>>>>>> in them.
They are valid proofs. Your work, if it contradicts those >>>>>>>>>> proofs (which
isn't at all clear) can thus be dismissed without further
consideration.
It has been constructed, and is valid. But one would normally >>>>>>>>>> talk aboutThere cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>>>> opposite of whatever its decider decides. All of the examples >>>>>>>>>>>>> of this have never been *ACTUAL INPUTS*
That's so sloppily worded, it could mean almost anything. >>>>>>>>>>The standard halting problem proof cannot even be constructed. >>>>>>>>>>
formulating a proof, rather than constructing one.
[ .... ]
No Turing machine can possibly take another directly executing >>>>>>>>>>>>> Turing machine as in input, thus removing these from the >>>>>>>>>>>>> domain of every halt decider.
And that, too.
*Thus the requirement that HHH report on the behavior* >>>>>>>>>>>>> *of the directly executed DD has always been bogus*
And that makes your hat trick.
Turing machine partial halt deciders compute the mapping >>>>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>>>> inputs specify.
And a fourth. There's some semblance of truth in there, but >>>>>>>>>>>> it's very
confused.
It is not at all confused. I know exactly what it means.
It's very confused to everybody but you, then.
Sloppy wording is your technique to get people to go down to >>>>>>>>>>>> your level
of discussion. That involves many posts trying just to tie >>>>>>>>>>>> you down to
specific word meanings, and is very tiresome and
unrewarding. I decline
to get involved any further.
*Yet as I claimed you found no actual mistake*
I've found plenty of actual mistakes. I was a software
developer by
profession.
Let me tell you the punchline so that you can
see why I said those things.
Despite what I said last post, I will actually go to the
trouble of
analysing your sloppy expression.
Because directly executed Turing machines cannot
possibly be inputs to Turing machine deciders this
makes them outside of the domain of these deciders.
It's entirely unclear what a "directly executed Turing
machine" is. Most
of the time turing machines are theoretical constructs used >>>>>>>>>> for proving
theorems. They can be executed, but rarely are.
It's unclear what you mean by a turing machine being an input >>>>>>>>>> to a turing
machine. Read up about universal turing machines to get a bit of >>>>>>>>>> background.
When a partial halt decider is required to report
on the direct execution of a machine this requirement
is bogus.
See above. That paragraph is meaningless.
This means that the behavior of DD() is none of the damn >>>>>>>>>>> business of HHH, thus does not contradict HHH(DD)==0.It's fully obscure what DD() and HHH mean, and thus impossible to >>>>>>>>>> affirm or contradict the meaningless "HHH(DD)==0".
*If you disagree this only proves that you do not understand* >>>>>>>>>>
HHH(DD) does correctly detect that DD simulated by HHH
according to the semantics pf the C programming language >>>>>>>>>>> cannot possibly reach its own "return"statement final
halt state.
See above. By the way, people concerned with computation >>>>>>>>>> theory use
turing machines, which are well-defined, simple, and powerful. >>>>>>>>>> They lack
the complexity, ambiguity, and unsuitability for theoretical >>>>>>>>>> work of real
world programming languages like C.
*If you disagree this only proves that you do not understand* >>>>>>>>>>Indeed. All you have done is disagree with one of the proofs >>>>>>>>>> of the
Any mindless idiot can disagree. Showing an error and proving >>>>>>>>>>> that it is an actual mistake requires much more than this. >>>>>>>>>>
halting theorem. You have yet to show an error in it. That >>>>>>>>>> will be
difficult, because there aren't any.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
This means nothing as long as symbols are undefined.
They are defined on the link provided on the next line.
That was not said in the quoted message, and some of the symbols
are not defined there.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
<*Halting Problem Proof ERROR*>
Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.
It is not clear what is the subject of the sentence. It makes a big >>>>>>>> difference who or what requires. Some requirements are essential to >>>>>>>> the topic but others may be irrelevant or even bogus.
<ChatGPT>
Misrepresentation of Input:
The standard proof assumes a decider
H(M,x) that determines whether machine
M halts on input x.
But this formulation is flawed, because:
Turing machines can only process finite
encodings (e.g. ⟨M⟩), not executable entities
like M.
So the valid formulation must be
H(⟨M⟩,x), where ⟨M⟩ is a string.
</ChatGPT>
This notation refers to Turing Machine: Ĥ
This notation refers to TM description: ⟨Ĥ⟩
The complete context is provided in the original proof
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
*Here is the corrected proof*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>>> reach its simulated final halt state of ⟨Ĥ.qn⟩.
Ĥ.embedded_H correctly transitions to Ĥ.qn.
The question about the missing subject remains unanswered. Apparently >>>>>> you don't know what you were talking about.
The key subject to me is this:
How does Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to Ĥ.qn correctly? >>>>>
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation until
embedded_H sees the repeating pattern and transitions to Ĥ.qn.
None of which is relevant to the point what is not a garamamtical
sentence cannot be true.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
*The above incorrect proof is corrected below*
What is above does not even claim to prove anything.
What is below is not a correct proof or anything.
You have to read the linked Linz proof to give that context. https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.
On 7/22/2025 5:58 AM, Mikko wrote:
On 2025-07-21 14:04:38 +0000, olcott said:
On 7/21/2025 4:28 AM, Mikko wrote:
On 2025-07-20 15:02:30 +0000, olcott said:
On 7/20/2025 3:39 AM, Mikko wrote:
On 2025-07-19 15:11:21 +0000, olcott said:
On 7/19/2025 3:05 AM, Mikko wrote:
On 2025-07-17 14:44:23 +0000, olcott said:
On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/6/2025 5:16 AM, Alan Mackenzie wrote:That's what I'm saying. Those proofs of the halting theorem are free
olcott <polcott333@gmail.com> wrote:
On 7/5/2025 2:07 PM, Alan Mackenzie wrote:
You lie. You don't have a proof. Many people in this group have pointed
out lots of errors in various versions of your purported proof, which you
just ignore. The section in Professor Linz's book you used to be so fond
of citing will contain plenty of details, if only you would take the
trouble to understand it (assuming you're capable of such understanding).
I have addressed ....
Meaningless pompous word.
.... all of those details that you make sure to ignore so that you can
baselessly claim that I am wrong.
I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>>>> understanding. It was like watching a 7 year old trying to do calculus.
The basic understanding was simply not there. Years later, it's still
not there.
And yes, you are wrong. The proofs of the halting theorem which involve
constructing programs which purported halting deciders cannot decide
correctly are correct.
Yet you cannot point to even one mistake because there are none. >>>>>>>>>>
from mistakes.
More to the point, it is YOU who cannot point to any mistakes in them.
They are valid proofs. Your work, if it contradicts those proofs (which
isn't at all clear) can thus be dismissed without further consideration.
It has been constructed, and is valid. But one would normally talk aboutThere cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>>>> opposite of whatever its decider decides. All of the examples >>>>>>>>>>>>> of this have never been *ACTUAL INPUTS*
That's so sloppily worded, it could mean almost anything. >>>>>>>>>>The standard halting problem proof cannot even be constructed. >>>>>>>>>>
formulating a proof, rather than constructing one.
[ .... ]
No Turing machine can possibly take another directly executing >>>>>>>>>>>>> Turing machine as in input, thus removing these from the >>>>>>>>>>>>> domain of every halt decider.
And that, too.
*Thus the requirement that HHH report on the behavior* >>>>>>>>>>>>> *of the directly executed DD has always been bogus*
And that makes your hat trick.
Turing machine partial halt deciders compute the mapping >>>>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>>>> inputs specify.
And a fourth. There's some semblance of truth in there, but it's very
confused.
It is not at all confused. I know exactly what it means.
It's very confused to everybody but you, then.
Sloppy wording is your technique to get people to go down to your level
of discussion. That involves many posts trying just to tie you down to
specific word meanings, and is very tiresome and unrewarding. I decline
to get involved any further.
*Yet as I claimed you found no actual mistake*
I've found plenty of actual mistakes. I was a software developer by
profession.
Let me tell you the punchline so that you can
see why I said those things.
Despite what I said last post, I will actually go to the trouble of >>>>>>>>>> analysing your sloppy expression.
Because directly executed Turing machines cannot
possibly be inputs to Turing machine deciders this
makes them outside of the domain of these deciders.
It's entirely unclear what a "directly executed Turing machine" is. Most
of the time turing machines are theoretical constructs used for proving
theorems. They can be executed, but rarely are.
It's unclear what you mean by a turing machine being an input to a turing
machine. Read up about universal turing machines to get a bit of >>>>>>>>>> background.
When a partial halt decider is required to report
on the direct execution of a machine this requirement
is bogus.
See above. That paragraph is meaningless.
This means that the behavior of DD() is none of the damn >>>>>>>>>>> business of HHH, thus does not contradict HHH(DD)==0.It's fully obscure what DD() and HHH mean, and thus impossible to >>>>>>>>>> affirm or contradict the meaningless "HHH(DD)==0".
*If you disagree this only proves that you do not understand* >>>>>>>>>>
HHH(DD) does correctly detect that DD simulated by HHH
according to the semantics pf the C programming language >>>>>>>>>>> cannot possibly reach its own "return"statement final
halt state.
See above. By the way, people concerned with computation theory use
turing machines, which are well-defined, simple, and powerful. They lack
the complexity, ambiguity, and unsuitability for theoretical work of real
world programming languages like C.
*If you disagree this only proves that you do not understand* >>>>>>>>>>Indeed. All you have done is disagree with one of the proofs of the
Any mindless idiot can disagree. Showing an error and proving >>>>>>>>>>> that it is an actual mistake requires much more than this. >>>>>>>>>>
halting theorem. You have yet to show an error in it. That will be
difficult, because there aren't any.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
This means nothing as long as symbols are undefined.
They are defined on the link provided on the next line.
That was not said in the quoted message, and some of the symbols
are not defined there.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
<*Halting Problem Proof ERROR*>
Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.
It is not clear what is the subject of the sentence. It makes a big >>>>>>>> difference who or what requires. Some requirements are essential to >>>>>>>> the topic but others may be irrelevant or even bogus.
<ChatGPT>
Misrepresentation of Input:
The standard proof assumes a decider
H(M,x) that determines whether machine
M halts on input x.
But this formulation is flawed, because:
Turing machines can only process finite
encodings (e.g. ⟨M⟩), not executable entities
like M.
So the valid formulation must be
H(⟨M⟩,x), where ⟨M⟩ is a string.
</ChatGPT>
This notation refers to Turing Machine: Ĥ
This notation refers to TM description: ⟨Ĥ⟩
The complete context is provided in the original proof
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
*Here is the corrected proof*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>>> reach its simulated final halt state of ⟨Ĥ.qn⟩.
Ĥ.embedded_H correctly transitions to Ĥ.qn.
The question about the missing subject remains unanswered. Apparently >>>>>> you don't know what you were talking about.
The key subject to me is this:
How does Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to Ĥ.qn correctly? >>>>>
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation until
embedded_H sees the repeating pattern and transitions to Ĥ.qn.
None of which is relevant to the point what is not a garamamtical
sentence cannot be true.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
*The above incorrect proof is corrected below*
What is above does not even claim to prove anything.
What is below is not a correct proof or anything.
You have to read the linked Linz proof to give that context. https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 7/23/2025 2:14 AM, Mikko wrote:
On 2025-07-22 14:00:09 +0000, olcott said:
On 7/22/2025 5:58 AM, Mikko wrote:
On 2025-07-21 14:04:38 +0000, olcott said:
On 7/21/2025 4:28 AM, Mikko wrote:
On 2025-07-20 15:02:30 +0000, olcott said:
On 7/20/2025 3:39 AM, Mikko wrote:
On 2025-07-19 15:11:21 +0000, olcott said:
On 7/19/2025 3:05 AM, Mikko wrote:
On 2025-07-17 14:44:23 +0000, olcott said:
On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 7/5/2025 2:07 PM, Alan Mackenzie wrote:
You lie. You don't have a proof. Many people in this >>>>>>>>>>>>>>>> group have pointed
out lots of errors in various versions of your purported >>>>>>>>>>>>>>>> proof, which you
just ignore. The section in Professor Linz's book you >>>>>>>>>>>>>>>> used to be so fond
of citing will contain plenty of details, if only you >>>>>>>>>>>>>>>> would take the
trouble to understand it (assuming you're capable of >>>>>>>>>>>>>>>> such understanding).
I have addressed ....
Meaningless pompous word.
.... all of those details that you make sure to ignore so >>>>>>>>>>>>>>> that you can
baselessly claim that I am wrong.
I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>>>>>> understanding. It was like watching a 7 year old trying >>>>>>>>>>>>>> to do calculus.
The basic understanding was simply not there. Years >>>>>>>>>>>>>> later, it's still
not there.
And yes, you are wrong. The proofs of the halting theorem >>>>>>>>>>>>>> which involve
constructing programs which purported halting deciders >>>>>>>>>>>>>> cannot decide
correctly are correct.
Yet you cannot point to even one mistake because there are >>>>>>>>>>>>> none.
That's what I'm saying. Those proofs of the halting theorem >>>>>>>>>>>> are free
from mistakes.
More to the point, it is YOU who cannot point to any
mistakes in them.
They are valid proofs. Your work, if it contradicts those >>>>>>>>>>>> proofs (which
isn't at all clear) can thus be dismissed without further >>>>>>>>>>>> consideration.
It has been constructed, and is valid. But one would >>>>>>>>>>>> normally talk aboutThere cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>>>>>> opposite of whatever its decider decides. All of the >>>>>>>>>>>>>>> examples
of this have never been *ACTUAL INPUTS*
That's so sloppily worded, it could mean almost anything. >>>>>>>>>>>>The standard halting problem proof cannot even be constructed. >>>>>>>>>>>>
formulating a proof, rather than constructing one.
[ .... ]
No Turing machine can possibly take another directly >>>>>>>>>>>>>>> executing
Turing machine as in input, thus removing these from the >>>>>>>>>>>>>>> domain of every halt decider.
And that, too.
*Thus the requirement that HHH report on the behavior* >>>>>>>>>>>>>>> *of the directly executed DD has always been bogus* >>>>>>>>>>>>And that makes your hat trick.
Turing machine partial halt deciders compute the mapping >>>>>>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>>>>>> inputs specify.
And a fourth. There's some semblance of truth in there, >>>>>>>>>>>>>> but it's very
confused.
It is not at all confused. I know exactly what it means. >>>>>>>>>>>>It's very confused to everybody but you, then.
Sloppy wording is your technique to get people to go down >>>>>>>>>>>>>> to your level
of discussion. That involves many posts trying just to >>>>>>>>>>>>>> tie you down to
specific word meanings, and is very tiresome and
unrewarding. I decline
to get involved any further.
*Yet as I claimed you found no actual mistake*
I've found plenty of actual mistakes. I was a software >>>>>>>>>>>> developer by
profession.
Let me tell you the punchline so that you can
see why I said those things.
Despite what I said last post, I will actually go to the >>>>>>>>>>>> trouble of
analysing your sloppy expression.
Because directly executed Turing machines cannot
possibly be inputs to Turing machine deciders this
makes them outside of the domain of these deciders.
It's entirely unclear what a "directly executed Turing >>>>>>>>>>>> machine" is. Most
of the time turing machines are theoretical constructs used >>>>>>>>>>>> for proving
theorems. They can be executed, but rarely are.
It's unclear what you mean by a turing machine being an >>>>>>>>>>>> input to a turing
machine. Read up about universal turing machines to get a >>>>>>>>>>>> bit of
background.
When a partial halt decider is required to report
on the direct execution of a machine this requirement >>>>>>>>>>>>> is bogus.
See above. That paragraph is meaningless.
This means that the behavior of DD() is none of the damn >>>>>>>>>>>>> business of HHH, thus does not contradict HHH(DD)==0. >>>>>>>>>>>>> *If you disagree this only proves that you do not understand* >>>>>>>>>>>>It's fully obscure what DD() and HHH mean, and thus
impossible to
affirm or contradict the meaningless "HHH(DD)==0".
HHH(DD) does correctly detect that DD simulated by HHH >>>>>>>>>>>>> according to the semantics pf the C programming language >>>>>>>>>>>>> cannot possibly reach its own "return"statement final >>>>>>>>>>>>> halt state.
See above. By the way, people concerned with computation >>>>>>>>>>>> theory use
turing machines, which are well-defined, simple, and
powerful. They lack
the complexity, ambiguity, and unsuitability for theoretical >>>>>>>>>>>> work of real
world programming languages like C.
*If you disagree this only proves that you do not understand* >>>>>>>>>>>>Indeed. All you have done is disagree with one of the >>>>>>>>>>>> proofs of the
Any mindless idiot can disagree. Showing an error and proving >>>>>>>>>>>>> that it is an actual mistake requires much more than this. >>>>>>>>>>>>
halting theorem. You have yet to show an error in it. That >>>>>>>>>>>> will be
difficult, because there aren't any.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
This means nothing as long as symbols are undefined.
They are defined on the link provided on the next line.
That was not said in the quoted message, and some of the symbols >>>>>>>> are not defined there.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
<*Halting Problem Proof ERROR*>
Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the >>>>>>>>>>> direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.
It is not clear what is the subject of the sentence. It makes >>>>>>>>>> a big
difference who or what requires. Some requirements are
essential to
the topic but others may be irrelevant or even bogus.
<ChatGPT>
Misrepresentation of Input:
The standard proof assumes a decider
H(M,x) that determines whether machine
M halts on input x.
But this formulation is flawed, because:
Turing machines can only process finite
encodings (e.g. ⟨M⟩), not executable entities
like M.
So the valid formulation must be
H(⟨M⟩,x), where ⟨M⟩ is a string.
</ChatGPT>
This notation refers to Turing Machine: Ĥ
This notation refers to TM description: ⟨Ĥ⟩
The complete context is provided in the original proof
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
*Here is the corrected proof*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ >>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches >>>>>>>>> its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>>>>> reach its simulated final halt state of ⟨Ĥ.qn⟩. >>>>>>>>>
Ĥ.embedded_H correctly transitions to Ĥ.qn.
The question about the missing subject remains unanswered.
Apparently
you don't know what you were talking about.
The key subject to me is this:
How does Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to Ĥ.qn correctly? >>>>>>>
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation until
embedded_H sees the repeating pattern and transitions to Ĥ.qn.
None of which is relevant to the point what is not a garamamtical
sentence cannot be true.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Nothing in that page is relevant to the meaning of non-sense.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
*The above incorrect proof is corrected below*
What is above does not even claim to prove anything.
What is below is not a correct proof or anything.
You have to read the linked Linz proof to give that context.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Context does not matter when noting is said.
He says 3.5 pages and my proof is best understood after reading them.
On 7/23/2025 2:14 AM, Mikko wrote:
On 2025-07-22 14:00:09 +0000, olcott said:
On 7/22/2025 5:58 AM, Mikko wrote:
On 2025-07-21 14:04:38 +0000, olcott said:
On 7/21/2025 4:28 AM, Mikko wrote:
On 2025-07-20 15:02:30 +0000, olcott said:
On 7/20/2025 3:39 AM, Mikko wrote:
On 2025-07-19 15:11:21 +0000, olcott said:
On 7/19/2025 3:05 AM, Mikko wrote:
On 2025-07-17 14:44:23 +0000, olcott said:
On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/6/2025 5:16 AM, Alan Mackenzie wrote:That's what I'm saying. Those proofs of the halting theorem are free
olcott <polcott333@gmail.com> wrote:
On 7/5/2025 2:07 PM, Alan Mackenzie wrote:
You lie. You don't have a proof. Many people in this group have pointed
out lots of errors in various versions of your purported proof, which you
just ignore. The section in Professor Linz's book you used to be so fond
of citing will contain plenty of details, if only you would take the
trouble to understand it (assuming you're capable of such understanding).
I have addressed ....
Meaningless pompous word.
.... all of those details that you make sure to ignore so that you can
baselessly claim that I am wrong.
I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>>>>>> understanding. It was like watching a 7 year old trying to do calculus.
The basic understanding was simply not there. Years later, it's still
not there.
And yes, you are wrong. The proofs of the halting theorem which involve
constructing programs which purported halting deciders cannot decide
correctly are correct.
Yet you cannot point to even one mistake because there are none. >>>>>>>>>>>>
from mistakes.
More to the point, it is YOU who cannot point to any mistakes in them.
They are valid proofs. Your work, if it contradicts those proofs (which
isn't at all clear) can thus be dismissed without further consideration.
It has been constructed, and is valid. But one would normally talk aboutThere cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>>>>>> opposite of whatever its decider decides. All of the examples >>>>>>>>>>>>>>> of this have never been *ACTUAL INPUTS*
That's so sloppily worded, it could mean almost anything. >>>>>>>>>>>>The standard halting problem proof cannot even be constructed. >>>>>>>>>>>>
formulating a proof, rather than constructing one.
[ .... ]
No Turing machine can possibly take another directly executing >>>>>>>>>>>>>>> Turing machine as in input, thus removing these from the >>>>>>>>>>>>>>> domain of every halt decider.
And that, too.
*Thus the requirement that HHH report on the behavior* >>>>>>>>>>>>>>> *of the directly executed DD has always been bogus* >>>>>>>>>>>>And that makes your hat trick.
Turing machine partial halt deciders compute the mapping >>>>>>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>>>>>> inputs specify.
And a fourth. There's some semblance of truth in there, but it's very
confused.
It is not at all confused. I know exactly what it means. >>>>>>>>>>>>It's very confused to everybody but you, then.
Sloppy wording is your technique to get people to go down to your level
of discussion. That involves many posts trying just to tie you down to
specific word meanings, and is very tiresome and unrewarding. I decline
to get involved any further.
*Yet as I claimed you found no actual mistake*
I've found plenty of actual mistakes. I was a software developer by
profession.
Let me tell you the punchline so that you can
see why I said those things.
Despite what I said last post, I will actually go to the trouble of
analysing your sloppy expression.
Because directly executed Turing machines cannot
possibly be inputs to Turing machine deciders this
makes them outside of the domain of these deciders.
It's entirely unclear what a "directly executed Turing machine" is. Most
of the time turing machines are theoretical constructs used for proving
theorems. They can be executed, but rarely are.
It's unclear what you mean by a turing machine being an input to a turing
machine. Read up about universal turing machines to get a bit of >>>>>>>>>>>> background.
When a partial halt decider is required to report
on the direct execution of a machine this requirement >>>>>>>>>>>>> is bogus.
See above. That paragraph is meaningless.
This means that the behavior of DD() is none of the damn >>>>>>>>>>>>> business of HHH, thus does not contradict HHH(DD)==0. >>>>>>>>>>>>> *If you disagree this only proves that you do not understand* >>>>>>>>>>>>It's fully obscure what DD() and HHH mean, and thus impossible to >>>>>>>>>>>> affirm or contradict the meaningless "HHH(DD)==0".
HHH(DD) does correctly detect that DD simulated by HHH >>>>>>>>>>>>> according to the semantics pf the C programming language >>>>>>>>>>>>> cannot possibly reach its own "return"statement final >>>>>>>>>>>>> halt state.
See above. By the way, people concerned with computation theory use
turing machines, which are well-defined, simple, and powerful. They lack
the complexity, ambiguity, and unsuitability for theoretical work of real
world programming languages like C.
*If you disagree this only proves that you do not understand* >>>>>>>>>>>>Indeed. All you have done is disagree with one of the proofs of the
Any mindless idiot can disagree. Showing an error and proving >>>>>>>>>>>>> that it is an actual mistake requires much more than this. >>>>>>>>>>>>
halting theorem. You have yet to show an error in it. That will be
difficult, because there aren't any.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
This means nothing as long as symbols are undefined.
They are defined on the link provided on the next line.
That was not said in the quoted message, and some of the symbols >>>>>>>> are not defined there.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
<*Halting Problem Proof ERROR*>
Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the >>>>>>>>>>> direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.
It is not clear what is the subject of the sentence. It makes a big >>>>>>>>>> difference who or what requires. Some requirements are essential to >>>>>>>>>> the topic but others may be irrelevant or even bogus.
<ChatGPT>
Misrepresentation of Input:
The standard proof assumes a decider
H(M,x) that determines whether machine
M halts on input x.
But this formulation is flawed, because:
Turing machines can only process finite
encodings (e.g. ⟨M⟩), not executable entities
like M.
So the valid formulation must be
H(⟨M⟩,x), where ⟨M⟩ is a string.
</ChatGPT>
This notation refers to Turing Machine: Ĥ
This notation refers to TM description: ⟨Ĥ⟩
The complete context is provided in the original proof
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
*Here is the corrected proof*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ >>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches >>>>>>>>> its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>>>>> reach its simulated final halt state of ⟨Ĥ.qn⟩. >>>>>>>>>
Ĥ.embedded_H correctly transitions to Ĥ.qn.
The question about the missing subject remains unanswered. Apparently >>>>>>>> you don't know what you were talking about.
The key subject to me is this:
How does Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to Ĥ.qn correctly? >>>>>>>
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation until
embedded_H sees the repeating pattern and transitions to Ĥ.qn.
None of which is relevant to the point what is not a garamamtical
sentence cannot be true.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Nothing in that page is relevant to the meaning of non-sense.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
*The above incorrect proof is corrected below*
What is above does not even claim to prove anything.
What is below is not a correct proof or anything.
You have to read the linked Linz proof to give that context.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Context does not matter when noting is said.
He says 3.5 pages and my proof is best understood after reading them.
On 7/24/2025 1:18 AM, Mikko wrote:
On 2025-07-23 11:47:34 +0000, olcott said:
On 7/23/2025 2:14 AM, Mikko wrote:
On 2025-07-22 14:00:09 +0000, olcott said:
On 7/22/2025 5:58 AM, Mikko wrote:
On 2025-07-21 14:04:38 +0000, olcott said:
On 7/21/2025 4:28 AM, Mikko wrote:
On 2025-07-20 15:02:30 +0000, olcott said:
On 7/20/2025 3:39 AM, Mikko wrote:None of which is relevant to the point what is not a garamamtical >>>>>>>> sentence cannot be true.
On 2025-07-19 15:11:21 +0000, olcott said:
On 7/19/2025 3:05 AM, Mikko wrote:
On 2025-07-17 14:44:23 +0000, olcott said:
On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote: >>>>>>>>>>>>>>> On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 7/5/2025 2:07 PM, Alan Mackenzie wrote:
You lie. You don't have a proof. Many people in this group have pointed
out lots of errors in various versions of your purported proof, which you
just ignore. The section in Professor Linz's book you used to be so fond
of citing will contain plenty of details, if only you would take the
trouble to understand it (assuming you're capable of such understanding).
I have addressed ....
Meaningless pompous word.
.... all of those details that you make sure to ignore so that you can
baselessly claim that I am wrong.
I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>>>>>>>> understanding. It was like watching a 7 year old trying to do calculus.
The basic understanding was simply not there. Years later, it's still
not there.
And yes, you are wrong. The proofs of the halting theorem which involve
constructing programs which purported halting deciders cannot decide
correctly are correct.
Yet you cannot point to even one mistake because there are none.
That's what I'm saying. Those proofs of the halting theorem are free
from mistakes.
More to the point, it is YOU who cannot point to any mistakes in them.
They are valid proofs. Your work, if it contradicts those proofs (which
isn't at all clear) can thus be dismissed without further consideration.
It has been constructed, and is valid. But one would normally talk aboutThere cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>>>>>>>> opposite of whatever its decider decides. All of the examples >>>>>>>>>>>>>>>>> of this have never been *ACTUAL INPUTS*
That's so sloppily worded, it could mean almost anything. >>>>>>>>>>>>>>The standard halting problem proof cannot even be constructed. >>>>>>>>>>>>>>
formulating a proof, rather than constructing one. >>>>>>>>>>>>>>
[ .... ]
No Turing machine can possibly take another directly executing
Turing machine as in input, thus removing these from the >>>>>>>>>>>>>>>>> domain of every halt decider.
And that, too.
*Thus the requirement that HHH report on the behavior* >>>>>>>>>>>>>>>>> *of the directly executed DD has always been bogus* >>>>>>>>>>>>>>And that makes your hat trick.
Turing machine partial halt deciders compute the mapping >>>>>>>>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>>>>>>>> inputs specify.
And a fourth. There's some semblance of truth in there, but it's very
confused.
It is not at all confused. I know exactly what it means. >>>>>>>>>>>>>>It's very confused to everybody but you, then.
Sloppy wording is your technique to get people to go down to your level
of discussion. That involves many posts trying just to tie you down to
specific word meanings, and is very tiresome and unrewarding. I decline
to get involved any further.
*Yet as I claimed you found no actual mistake*
I've found plenty of actual mistakes. I was a software developer by
profession.
Let me tell you the punchline so that you can
see why I said those things.
Despite what I said last post, I will actually go to the trouble of
analysing your sloppy expression.
Because directly executed Turing machines cannot >>>>>>>>>>>>>>> possibly be inputs to Turing machine deciders this >>>>>>>>>>>>>>> makes them outside of the domain of these deciders. >>>>>>>>>>>>>>It's entirely unclear what a "directly executed Turing machine" is. Most
of the time turing machines are theoretical constructs used for proving
theorems. They can be executed, but rarely are.
It's unclear what you mean by a turing machine being an input to a turing
machine. Read up about universal turing machines to get a bit of
background.
When a partial halt decider is required to report >>>>>>>>>>>>>>> on the direct execution of a machine this requirement >>>>>>>>>>>>>>> is bogus.
See above. That paragraph is meaningless.
This means that the behavior of DD() is none of the damn >>>>>>>>>>>>>>> business of HHH, thus does not contradict HHH(DD)==0. >>>>>>>>>>>>>>> *If you disagree this only proves that you do not understand* >>>>>>>>>>>>>>It's fully obscure what DD() and HHH mean, and thus impossible to
affirm or contradict the meaningless "HHH(DD)==0". >>>>>>>>>>>>>>
HHH(DD) does correctly detect that DD simulated by HHH >>>>>>>>>>>>>>> according to the semantics pf the C programming language >>>>>>>>>>>>>>> cannot possibly reach its own "return"statement final >>>>>>>>>>>>>>> halt state.
See above. By the way, people concerned with computation theory use
turing machines, which are well-defined, simple, and powerful. They lack
the complexity, ambiguity, and unsuitability for theoretical work of real
world programming languages like C.
*If you disagree this only proves that you do not understand* >>>>>>>>>>>>>>Indeed. All you have done is disagree with one of the proofs of the
Any mindless idiot can disagree. Showing an error and proving >>>>>>>>>>>>>>> that it is an actual mistake requires much more than this. >>>>>>>>>>>>>>
halting theorem. You have yet to show an error in it. That will be
difficult, because there aren't any.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
This means nothing as long as symbols are undefined.
They are defined on the link provided on the next line.
That was not said in the quoted message, and some of the symbols >>>>>>>>>> are not defined there.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>It is not clear what is the subject of the sentence. It makes a big
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
<*Halting Problem Proof ERROR*>
Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the >>>>>>>>>>>>> direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not >>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H. >>>>>>>>>>>>
difference who or what requires. Some requirements are essential to
the topic but others may be irrelevant or even bogus.
<ChatGPT>
Misrepresentation of Input:
The standard proof assumes a decider
H(M,x) that determines whether machine
M halts on input x.
But this formulation is flawed, because:
Turing machines can only process finite
encodings (e.g. ⟨M⟩), not executable entities
like M.
So the valid formulation must be
H(⟨M⟩,x), where ⟨M⟩ is a string.
</ChatGPT>
This notation refers to Turing Machine: Ĥ
This notation refers to TM description: ⟨Ĥ⟩
The complete context is provided in the original proof
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
*Here is the corrected proof*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ >>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches >>>>>>>>>>> its simulated final halt state of ⟨Ĥ.qn⟩, and >>>>>>>>>>>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩. >>>>>>>>>>>
Ĥ.embedded_H correctly transitions to Ĥ.qn.
The question about the missing subject remains unanswered. Apparently
you don't know what you were talking about.
The key subject to me is this:
How does Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to Ĥ.qn correctly?
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation until
embedded_H sees the repeating pattern and transitions to Ĥ.qn. >>>>>>>>
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Nothing in that page is relevant to the meaning of non-sense.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>> if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
*The above incorrect proof is corrected below*
What is above does not even claim to prove anything.
What is below is not a correct proof or anything.
You have to read the linked Linz proof to give that context.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Context does not matter when noting is said.
He says 3.5 pages and my proof is best understood after reading them.
Understanding that you said nothing does not require reading what
Linz says. If one reads it anyway one only finds that it does not
give any meaning to your babble.
So you are refusing to look at what I have said in its context.
On 7/25/2025 2:35 AM, Mikko wrote:
On 2025-07-24 12:46:40 +0000, olcott said:
On 7/24/2025 1:18 AM, Mikko wrote:
On 2025-07-23 11:47:34 +0000, olcott said:
On 7/23/2025 2:14 AM, Mikko wrote:Understanding that you said nothing does not require reading what
On 2025-07-22 14:00:09 +0000, olcott said:>>>>>>
You have to read the linked Linz proof to give that context.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Context does not matter when noting is said.
He says 3.5 pages and my proof is best understood after reading them. >>>>
Linz says. If one reads it anyway one only finds that it does not
give any meaning to your babble.
So you are refusing to look at what I have said in its context.
You are lying. I did tell what I found when I looked at it in its
context.
It is libelous that you call me a liar.
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
if M applied to WM halts, and
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2,
if M applied to WM does not halt.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
Until you understand that my adaptation of the
Linz notation is correct we cannot proceed to
the next steps.
On 7/25/2025 2:35 AM, Mikko wrote:
On 2025-07-24 12:46:40 +0000, olcott said:
On 7/24/2025 1:18 AM, Mikko wrote:
On 2025-07-23 11:47:34 +0000, olcott said:
On 7/23/2025 2:14 AM, Mikko wrote:Understanding that you said nothing does not require reading what
On 2025-07-22 14:00:09 +0000, olcott said:>>>>>>
You have to read the linked Linz proof to give that context.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Context does not matter when noting is said.
He says 3.5 pages and my proof is best understood after reading them. >>>>
Linz says. If one reads it anyway one only finds that it does not
give any meaning to your babble.
So you are refusing to look at what I have said in its context.
You are lying. I did tell what I found when I looked at it in its context.
It is libelous that you call me a liar.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 152:08:56 |
| Calls: | 10,383 |
| Files: | 14,054 |
| Messages: | 6,417,815 |