On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If >>>>>>>>>>>>> so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>> includes all possible output sequences, it is not solvable >>>>>>>>>>>> for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" or >>>>>>>>>> "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I said. >>>>>>>> Though Linz says nothing about "embedded_H", either; that is
your own interpolation. And you omitted important parts of the >>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to
already
know what a proof is (if necessary, they can find that in other boods). >>>> It is easy to see that that proof is correct. Similar proofs with the
same conclusion are shown in other books, and some people may find one >>>> of them even easier to check.
What may need to an explanation is the exact meaning of the conclusion. >>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show"
that with the fallacy of equivocation.
I show that DD correctly simulated by HHH
cannot possibly reach its own final state
while DD is being simulated by HHH.
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
On 31/10/2026 14:23, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? >>>>>>>>>>>>>> If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>> includes all possible output sequences, it is not solvable >>>>>>>>>>>>> for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" >>>>>>>>>>> or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I said. >>>>>>>>> Though Linz says nothing about "embedded_H", either; that is >>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to
already
know what a proof is (if necessary, they can find that in other
boods).
It is easy to see that that proof is correct. Similar proofs with the >>>>> same conclusion are shown in other books, and some people may find one >>>>> of them even easier to check.
What may need to an explanation is the exact meaning of the
conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show"
that with the fallacy of equivocation.
I show that DD correctly simulated by HHH
cannot possibly reach its own final state
while DD is being simulated by HHH.
What matters is how you "show" that.
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
Readers may and should take every identification of a fallacy as
a rebuttal, whether the author accepts it or not.
On 11/6/2026 2:29 AM, Mikko wrote:
On 31/10/2026 14:23, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? >>>>>>>>>>>>>>> If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>> includes all possible output sequences, it is not solvable >>>>>>>>>>>>>> for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior >>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" >>>>>>>>>>>> or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I said. >>>>>>>>>> Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to
already
know what a proof is (if necessary, they can find that in other
boods).
It is easy to see that that proof is correct. Similar proofs with the >>>>>> same conclusion are shown in other books, and some people may find >>>>>> one
of them even easier to check.
What may need to an explanation is the exact meaning of the
conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show"
that with the fallacy of equivocation.
I show that DD correctly simulated by HHH
cannot possibly reach its own final state
while DD is being simulated by HHH.
What matters is how you "show" that.
If you don't know the C programming language
then it cannot be shown to you.
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If >>>>>>>>>>>>> so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>> includes all possible output sequences, it is not solvable >>>>>>>>>>>> for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" or >>>>>>>>>> "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I said. >>>>>>>> Though Linz says nothing about "embedded_H", either; that is
your own interpolation. And you omitted important parts of the >>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to
already
know what a proof is (if necessary, they can find that in other boods). >>>> It is easy to see that that proof is correct. Similar proofs with the
same conclusion are shown in other books, and some people may find one >>>> of them even easier to check.
What may need to an explanation is the exact meaning of the conclusion. >>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show"
that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
On 06/11/2026 16:09, olcott wrote:
On 11/6/2026 2:29 AM, Mikko wrote:
On 31/10/2026 14:23, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? >>>>>>>>>>>>>>>> If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>>> includes all possible output sequences, it is not >>>>>>>>>>>>>>> solvable for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior >>>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" >>>>>>>>>>>>> or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I said. >>>>>>>>>>> Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to >>>>>>> already
know what a proof is (if necessary, they can find that in other >>>>>>> boods).
It is easy to see that that proof is correct. Similar proofs with >>>>>>> the
same conclusion are shown in other books, and some people may
find one
of them even easier to check.
What may need to an explanation is the exact meaning of the
conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show"
that with the fallacy of equivocation.
I show that DD correctly simulated by HHH
cannot possibly reach its own final state
while DD is being simulated by HHH.
What matters is how you "show" that.
If you don't know the C programming language
then it cannot be shown to you.
If you keep presenting yourself like a liar some peple might believe
you really are a liar.
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? >>>>>>>>>>>>>> If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>> includes all possible output sequences, it is not solvable >>>>>>>>>>>>> for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" >>>>>>>>>>> or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I said. >>>>>>>>> Though Linz says nothing about "embedded_H", either; that is >>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to
already
know what a proof is (if necessary, they can find that in other
boods).
It is easy to see that that proof is correct. Similar proofs with the >>>>> same conclusion are shown in other books, and some people may find one >>>>> of them even easier to check.
What may need to an explanation is the exact meaning of the
conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show"
that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually from a
file or a set of files) and behaves as that C program specifies.
It is significantly less efficient than a compiler based implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an intermediate language that can be interpreted with a fast interpreter
like Java Virtual Machine.
On 11/10/2026 2:08 AM, Mikko wrote:
On 06/11/2026 16:09, olcott wrote:
On 11/6/2026 2:29 AM, Mikko wrote:
On 31/10/2026 14:23, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>>>> includes all possible output sequences, it is not >>>>>>>>>>>>>>>> solvable for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior >>>>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>> "DD()" or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I >>>>>>>>>>>> said.
Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to >>>>>>>> already
know what a proof is (if necessary, they can find that in other >>>>>>>> boods).
It is easy to see that that proof is correct. Similar proofs
with the
same conclusion are shown in other books, and some people may >>>>>>>> find one
of them even easier to check.
What may need to an explanation is the exact meaning of the
conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show" >>>>>> that with the fallacy of equivocation.
I show that DD correctly simulated by HHH
cannot possibly reach its own final state
while DD is being simulated by HHH.
What matters is how you "show" that.
If you don't know the C programming language
then it cannot be shown to you.
If you keep presenting yourself like a liar some peple might believe
you really are a liar.
I am not the one that simply dodged the question
about my knowledge of C.
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? >>>>>>>>>>>>>>> If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>> includes all possible output sequences, it is not solvable >>>>>>>>>>>>>> for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior >>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" >>>>>>>>>>>> or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I said. >>>>>>>>>> Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to
already
know what a proof is (if necessary, they can find that in other
boods).
It is easy to see that that proof is correct. Similar proofs with the >>>>>> same conclusion are shown in other books, and some people may find >>>>>> one
of them even easier to check.
What may need to an explanation is the exact meaning of the
conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show"
that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually from a
file or a set of files) and behaves as that C program specifies.
It is significantly less efficient than a compiler based implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an
intermediate language that can be interpreted with a fast interpreter
like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
On 10/11/2026 17:04, olcott wrote:
On 11/10/2026 2:08 AM, Mikko wrote:
On 06/11/2026 16:09, olcott wrote:
On 11/6/2026 2:29 AM, Mikko wrote:
On 31/10/2026 14:23, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>>>>> includes all possible output sequences, it is not >>>>>>>>>>>>>>>>> solvable for all possible machines
The key mistake of the halting theorem is that >>>>>>>>>>>>>>>> it requires a halt decider to report on the behavior >>>>>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>>> "DD()" or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I >>>>>>>>>>>>> said.
Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed >>>>>>>>> to already
know what a proof is (if necessary, they can find that in other >>>>>>>>> boods).
It is easy to see that that proof is correct. Similar proofs >>>>>>>>> with the
same conclusion are shown in other books, and some people may >>>>>>>>> find one
of them even easier to check.
What may need to an explanation is the exact meaning of the >>>>>>>>> conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show" >>>>>>> that with the fallacy of equivocation.
I show that DD correctly simulated by HHH
cannot possibly reach its own final state
while DD is being simulated by HHH.
What matters is how you "show" that.
If you don't know the C programming language
then it cannot be shown to you.
If you keep presenting yourself like a liar some peple might believe
you really are a liar.
I am not the one that simply dodged the question
about my knowledge of C.
Indeed, you are the one that dodged on-topic questions.
On 10/11/2026 17:06, olcott wrote:
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? >>>>>>>>>>>>>>>> If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>>> includes all possible output sequences, it is not >>>>>>>>>>>>>>> solvable for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior >>>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" >>>>>>>>>>>>> or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I said. >>>>>>>>>>> Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to >>>>>>> already
know what a proof is (if necessary, they can find that in other >>>>>>> boods).
It is easy to see that that proof is correct. Similar proofs with >>>>>>> the
same conclusion are shown in other books, and some people may
find one
of them even easier to check.
What may need to an explanation is the exact meaning of the
conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show"
that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually from a
file or a set of files) and behaves as that C program specifies.
It is significantly less efficient than a compiler based implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an
intermediate language that can be interpreted with a fast interpreter
like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
Although I havn't worked woth any x86 since long ago I still know
quite a lot about it. But details of the machine code are irrelevant
to the genral topics discussed in comp.theory.
On 11/11/2026 3:13 AM, Mikko wrote:
On 10/11/2026 17:06, olcott wrote:
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>>>> includes all possible output sequences, it is not >>>>>>>>>>>>>>>> solvable for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior >>>>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>> "DD()" or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I >>>>>>>>>>>> said.
Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed to >>>>>>>> already
know what a proof is (if necessary, they can find that in other >>>>>>>> boods).
It is easy to see that that proof is correct. Similar proofs
with the
same conclusion are shown in other books, and some people may >>>>>>>> find one
of them even easier to check.
What may need to an explanation is the exact meaning of the
conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show" >>>>>> that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually from a
file or a set of files) and behaves as that C program specifies.
It is significantly less efficient than a compiler based implementation >>>> so rarely used if ever.
A more practical implementation is to translate a C program to an
intermediate language that can be interpreted with a fast interpreter
like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
Although I havn't worked woth any x86 since long ago I still know
quite a lot about it. But details of the machine code are irrelevant
to the genral topics discussed in comp.theory.
HHH works on the basis of the x86 code because the
x86 code provides a ready made directly graph of
all control flow. This same thing can be understood
much more easily at the C level is one knows C. If
one does not know C then they cannot possibly understand
what I am saying.
On 11/11/2026 16:10, olcott wrote:
On 11/11/2026 3:13 AM, Mikko wrote:
On 10/11/2026 17:06, olcott wrote:
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:Having the same role does not mean being the same.
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>>>>> includes all possible output sequences, it is not >>>>>>>>>>>>>>>>> solvable for all possible machines
The key mistake of the halting theorem is that >>>>>>>>>>>>>>>> it requires a halt decider to report on the behavior >>>>>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>>> "DD()" or "main()".
The halting problem asks "How can one determine whether a >>>>>>>>>>>>>>> computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are >>>>>>>>>>>>>> also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I >>>>>>>>>>>>> said.
Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>>>>> your own interpolation. And you omitted important parts of the >>>>>>>>>>>>> definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main() >>>>>>>>>>>
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed >>>>>>>>> to already
know what a proof is (if necessary, they can find that in other >>>>>>>>> boods).
It is easy to see that that proof is correct. Similar proofs >>>>>>>>> with the
same conclusion are shown in other books, and some people may >>>>>>>>> find one
of them even easier to check.
What may need to an explanation is the exact meaning of the >>>>>>>>> conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show" >>>>>>> that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually from a
file or a set of files) and behaves as that C program specifies.
It is significantly less efficient than a compiler based
implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an
intermediate language that can be interpreted with a fast interpreter >>>>> like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
Although I havn't worked woth any x86 since long ago I still know
quite a lot about it. But details of the machine code are irrelevant
to the genral topics discussed in comp.theory.
HHH works on the basis of the x86 code because the
x86 code provides a ready made directly graph of
all control flow. This same thing can be understood
much more easily at the C level is one knows C. If
one does not know C then they cannot possibly understand
what I am saying.
If you can express your claims so in a way that a respectable journal
accepts you will be understood. Otherwise it does not matter.
On 11/12/2026 3:12 AM, Mikko wrote:
If you can express your claims so in a way that a respectable journal accepts you will be understood. Otherwise it does not matter.
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
Now that I can finally anchor my views in accepted
terms-of-the-art definitions it will possible to
explain my view to people that are deeply motivated
to understand rather than simply reject what I am
saying.
----
Copyright 2026 Olcott
On 11/12/2026 3:12 AM, Mikko wrote:
On 11/11/2026 16:10, olcott wrote:
On 11/11/2026 3:13 AM, Mikko wrote:
On 10/11/2026 17:06, olcott wrote:
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>>>>>> includes all possible output sequences, it is not >>>>>>>>>>>>>>>>>> solvable for all possible machines
The key mistake of the halting theorem is that >>>>>>>>>>>>>>>>> it requires a halt decider to report on the behavior >>>>>>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>>>> "DD()" or "main()".
The halting problem asks "How can one determine whether >>>>>>>>>>>>>>>> a computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H >>>>>>>>>>>>>>> are
also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I >>>>>>>>>>>>>> said.
Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>>>>>> your own interpolation. And you omitted important parts of >>>>>>>>>>>>>> the
definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main()
Having the same role does not mean being the same.
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed >>>>>>>>>> to already
know what a proof is (if necessary, they can find that in >>>>>>>>>> other boods).
It is easy to see that that proof is correct. Similar proofs >>>>>>>>>> with the
same conclusion are shown in other books, and some people may >>>>>>>>>> find one
of them even easier to check.
What may need to an explanation is the exact meaning of the >>>>>>>>>> conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show" >>>>>>>> that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually from a >>>>>> file or a set of files) and behaves as that C program specifies.
It is significantly less efficient than a compiler based
implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an
intermediate language that can be interpreted with a fast interpreter >>>>>> like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
Although I havn't worked woth any x86 since long ago I still know
quite a lot about it. But details of the machine code are irrelevant
to the genral topics discussed in comp.theory.
HHH works on the basis of the x86 code because the
x86 code provides a ready made directly graph of
all control flow. This same thing can be understood
much more easily at the C level is one knows C. If
one does not know C then they cannot possibly understand
what I am saying.
If you can express your claims so in a way that a respectable journal
accepts you will be understood. Otherwise it does not matter.
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
Now that I can finally anchor my views in accepted
terms-of-the-art definitions it will possible to
explain my view to people that are deeply motivated
to understand rather than simply reject what I am
saying.
polcott <polcott333@gmail.com> wrote:
On 11/12/2026 3:12 AM, Mikko wrote:
[ .... ]
If you can express your claims so in a way that a respectable journal
accepts you will be understood. Otherwise it does not matter.
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
The Halting Theorem has been proven, and the proofs verified by millions
of academics, students, and other interested people. It is such a simple theorem that there is no doubt as to its correctness. The only reason
for glanching at contrary "reasoning" is to find the errors in that
alleged reasoning and point the mistaken reasoner at the truth.
Now that I can finally anchor my views in accepted
terms-of-the-art definitions it will possible to
explain my view to people that are deeply motivated
to understand rather than simply reject what I am
saying.
Views are irrelevant. Only mathematically proven truths matter here.
--
Copyright 2026 Olcott
On 11/12/2026 9:34 AM, Alan Mackenzie wrote:
polcott <polcott333@gmail.com> wrote:
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
The Halting Theorem has been proven, and the proofs verified by
millions of academics, students, and other interested people. It is
such a simple theorem that there is no doubt as to its correctness.
The only reason for glanching at contrary "reasoning" is to find the
errors in that alleged reasoning and point the mistaken reasoner at
the truth.
Only because of key details that were simply abstracted away.
While those details remain invisible it is a tautology that
the halting problem proof is correct in some sense.
As I showed back in 2004 The HP is essentially the Liar
Paradox ion disguise. [ .... ]
----
Copyright 2026 Olcott
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 11/12/2026 9:34 AM, Alan Mackenzie wrote:
polcott <polcott333@gmail.com> wrote:
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
The Halting Theorem has been proven, and the proofs verified by
millions of academics, students, and other interested people. It is
such a simple theorem that there is no doubt as to its correctness.
The only reason for glanching at contrary "reasoning" is to find the
errors in that alleged reasoning and point the mistaken reasoner at
the truth.
Only because of key details that were simply abstracted away.
While those details remain invisible it is a tautology that
the halting problem proof is correct in some sense.
You're simply wrong. Irrelevant details were abstracted away, as they typically are in a mathematical proof.
The man who developed the first proof, Alan Turing, was a good candidate
for the brightest intellect on the planet when he was alive. He was a trained mathematician, too. Such people do not omit key details from
proofs; if they did, they'd be picked up by the peer review to which
their results are subject.
The halting problem proofs are correct. You do not have the mathematical ability to understand any of them, so anything you say about them is pure meaningless irrelevance.
As I showed back in 2004 The HP is essentially the Liar
Paradox ion disguise. [ .... ]
That's wrong, has nothing to do with the halting problem, and everything
to do with your personal lack of intellectual capacity. You have never
shown (synonym for proven) anything mathematical. You don't even grasp
what the word means.
[ .... ]
--
Copyright 2026 Olcott
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 11/12/2026 9:34 AM, Alan Mackenzie wrote:
polcott <polcott333@gmail.com> wrote:
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
The Halting Theorem has been proven, and the proofs verified by
millions of academics, students, and other interested people. It is
such a simple theorem that there is no doubt as to its correctness.
The only reason for glanching at contrary "reasoning" is to find the
errors in that alleged reasoning and point the mistaken reasoner at
the truth.
Only because of key details that were simply abstracted away.
While those details remain invisible it is a tautology that
the halting problem proof is correct in some sense.
You're simply wrong. Irrelevant details were abstracted away, as they typically are in a mathematical proof.
The man who developed the first proof, Alan Turing, was a good candidate
for the brightest intellect on the planet when he was alive. He was a trained mathematician, too. Such people do not omit key details from
proofs; if they did, they'd be picked up by the peer review to which
their results are subject.
The halting problem proofs are correct. You do not have the mathematical ability to understand any of them, so anything you say about them is pure meaningless irrelevance.
As I showed back in 2004 The HP is essentially the Liar
Paradox ion disguise. [ .... ]
That's wrong, has nothing to do with the halting problem, and everything
to do with your personal lack of intellectual capacity. You have never
shown (synonym for proven) anything mathematical. You don't even grasp
what the word means.
[ .... ]
--
Copyright 2026 Olcott
On 11/12/2026 3:12 AM, Mikko wrote:
On 11/11/2026 16:10, olcott wrote:
On 11/11/2026 3:13 AM, Mikko wrote:
On 10/11/2026 17:06, olcott wrote:
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>>>>>> includes all possible output sequences, it is not >>>>>>>>>>>>>>>>>> solvable for all possible machines
The key mistake of the halting theorem is that >>>>>>>>>>>>>>>>> it requires a halt decider to report on the behavior >>>>>>>>>>>>>>>>> of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>>>> "DD()" or "main()".
The halting problem asks "How can one determine whether >>>>>>>>>>>>>>>> a computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H >>>>>>>>>>>>>>> are
also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as I >>>>>>>>>>>>>> said.
Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>>>>>> your own interpolation. And you omitted important parts of >>>>>>>>>>>>>> the
definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main()
Having the same role does not mean being the same.
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed >>>>>>>>>> to already
know what a proof is (if necessary, they can find that in >>>>>>>>>> other boods).
It is easy to see that that proof is correct. Similar proofs >>>>>>>>>> with the
same conclusion are shown in other books, and some people may >>>>>>>>>> find one
of them even easier to check.
What may need to an explanation is the exact meaning of the >>>>>>>>>> conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only "show" >>>>>>>> that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually from a >>>>>> file or a set of files) and behaves as that C program specifies.
It is significantly less efficient than a compiler based
implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an
intermediate language that can be interpreted with a fast interpreter >>>>>> like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
Although I havn't worked woth any x86 since long ago I still know
quite a lot about it. But details of the machine code are irrelevant
to the genral topics discussed in comp.theory.
HHH works on the basis of the x86 code because the
x86 code provides a ready made directly graph of
all control flow. This same thing can be understood
much more easily at the C level is one knows C. If
one does not know C then they cannot possibly understand
what I am saying.
If you can express your claims so in a way that a respectable journal
accepts you will be understood. Otherwise it does not matter.
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
On 12/11/2026 16:57, polcott wrote:
On 11/12/2026 3:12 AM, Mikko wrote:
On 11/11/2026 16:10, olcott wrote:
On 11/11/2026 3:13 AM, Mikko wrote:
On 10/11/2026 17:06, olcott wrote:
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>>>>> "DD()" or "main()".
On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines that >>>>>>>>>>>>>>>>>>> includes all possible output sequences, it is not >>>>>>>>>>>>>>>>>>> solvable for all possible machines
The key mistake of the halting theorem is that >>>>>>>>>>>>>>>>>> it requires a halt decider to report on the behavior >>>>>>>>>>>>>>>>>> of the direct execution of DD() from main() >>>>>>>>>>>>>>>>>
The halting problem asks "How can one determine whether >>>>>>>>>>>>>>>>> a computation
halts?"
Here is the same thing from Linz where H and
-n.embedded_H are
also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as >>>>>>>>>>>>>>> I said.
Though Linz says nothing about "embedded_H", either; that is >>>>>>>>>>>>>>> your own interpolation. And you omitted important parts >>>>>>>>>>>>>>> of the
definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main()
Having the same role does not mean being the same.
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are assumed >>>>>>>>>>> to already
know what a proof is (if necessary, they can find that in >>>>>>>>>>> other boods).
It is easy to see that that proof is correct. Similar proofs >>>>>>>>>>> with the
same conclusion are shown in other books, and some people may >>>>>>>>>>> find one
of them even easier to check.
What may need to an explanation is the exact meaning of the >>>>>>>>>>> conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only >>>>>>>>> "show"
that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually from a >>>>>>> file or a set of files) and behaves as that C program specifies. >>>>>>> It is significantly less efficient than a compiler based
implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an >>>>>>> intermediate language that can be interpreted with a fast
interpreter
like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
Although I havn't worked woth any x86 since long ago I still know
quite a lot about it. But details of the machine code are irrelevant >>>>> to the genral topics discussed in comp.theory.
HHH works on the basis of the x86 code because the
x86 code provides a ready made directly graph of
all control flow. This same thing can be understood
much more easily at the C level is one knows C. If
one does not know C then they cannot possibly understand
what I am saying.
If you can express your claims so in a way that a respectable journal
accepts you will be understood. Otherwise it does not matter.
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
A mathematical proof is not exactly the same as an indoctrination
although they tend to have similar effects on peoples beliefs.
On 11/13/2026 3:10 AM, Mikko wrote:
On 12/11/2026 16:57, polcott wrote:
On 11/12/2026 3:12 AM, Mikko wrote:
On 11/11/2026 16:10, olcott wrote:
On 11/11/2026 3:13 AM, Mikko wrote:
On 10/11/2026 17:06, olcott wrote:
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:
On 10/24/2026 2:55 AM, Mikko wrote:
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>>>>>> "DD()" or "main()".
On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>> [...]
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines >>>>>>>>>>>>>>>>>>>> that includes all possible output sequences, it is >>>>>>>>>>>>>>>>>>>> not solvable for all possible machines
The key mistake of the halting theorem is that >>>>>>>>>>>>>>>>>>> it requires a halt decider to report on the behavior >>>>>>>>>>>>>>>>>>> of the direct execution of DD() from main() >>>>>>>>>>>>>>>>>>
The halting problem asks "How can one determine >>>>>>>>>>>>>>>>>> whether a computation
halts?"
Here is the same thing from Linz where H and >>>>>>>>>>>>>>>>> -n.embedded_H are
also based on UTM simulation of their inputs. >>>>>>>>>>>>>>>>>
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just as >>>>>>>>>>>>>>>> I said.
Though Linz says nothing about "embedded_H", either; >>>>>>>>>>>>>>>> that is
your own interpolation. And you omitted important parts >>>>>>>>>>>>>>>> of the
definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from main()
Having the same role does not mean being the same.
It means isomorphic that means that the Linz proof
can be explained by my proof.
There is no need to explain Linz's proof. Readers are >>>>>>>>>>>> assumed to already
know what a proof is (if necessary, they can find that in >>>>>>>>>>>> other boods).
It is easy to see that that proof is correct. Similar proofs >>>>>>>>>>>> with the
same conclusion are shown in other books, and some people >>>>>>>>>>>> may find one
of them even easier to check.
What may need to an explanation is the exact meaning of the >>>>>>>>>>>> conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only >>>>>>>>>> "show"
that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually from a >>>>>>>> file or a set of files) and behaves as that C program specifies. >>>>>>>> It is significantly less efficient than a compiler based
implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an >>>>>>>> intermediate language that can be interpreted with a fast
interpreter
like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
Although I havn't worked woth any x86 since long ago I still know
quite a lot about it. But details of the machine code are irrelevant >>>>>> to the genral topics discussed in comp.theory.
HHH works on the basis of the x86 code because the
x86 code provides a ready made directly graph of
all control flow. This same thing can be understood
much more easily at the C level is one knows C. If
one does not know C then they cannot possibly understand
what I am saying.
If you can express your claims so in a way that a respectable journal
accepts you will be understood. Otherwise it does not matter.
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
A mathematical proof is not exactly the same as an indoctrination
although they tend to have similar effects on peoples beliefs.
Some aspects of math do seem to be infallible.
Things such as the principle of explosion and
Disjunction introduction are simply wrong headed.
On 13/11/2026 16:44, olcott wrote:
On 11/13/2026 3:10 AM, Mikko wrote:
On 12/11/2026 16:57, polcott wrote:
On 11/12/2026 3:12 AM, Mikko wrote:
On 11/11/2026 16:10, olcott wrote:
On 11/11/2026 3:13 AM, Mikko wrote:
On 10/11/2026 17:06, olcott wrote:
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:It means isomorphic that means that the Linz proof >>>>>>>>>>>>>> can be explained by my proof.
On 10/24/2026 2:55 AM, Mikko wrote:
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>> On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> [...]No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>>>>>>> "DD()" or "main()".
The key mistake of the halting theorem is that >>>>>>>>>>>>>>>>>>>> it requires a halt decider to report on the behavior >>>>>>>>>>>>>>>>>>>> of the direct execution of DD() from main() >>>>>>>>>>>>>>>>>>>
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines >>>>>>>>>>>>>>>>>>>>> that includes all possible output sequences, it is >>>>>>>>>>>>>>>>>>>>> not solvable for all possible machines >>>>>>>>>>>>>>>>>>>>
The halting problem asks "How can one determine >>>>>>>>>>>>>>>>>>> whether a computation
halts?"
Here is the same thing from Linz where H and >>>>>>>>>>>>>>>>>> -n.embedded_H are
also based on UTM simulation of their inputs. >>>>>>>>>>>>>>>>>>
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just >>>>>>>>>>>>>>>>> as I said.
Though Linz says nothing about "embedded_H", either; >>>>>>>>>>>>>>>>> that is
your own interpolation. And you omitted important parts >>>>>>>>>>>>>>>>> of the
definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from >>>>>>>>>>>>>>>> main()
Having the same role does not mean being the same. >>>>>>>>>>>>>>
There is no need to explain Linz's proof. Readers are >>>>>>>>>>>>> assumed to already
know what a proof is (if necessary, they can find that in >>>>>>>>>>>>> other boods).
It is easy to see that that proof is correct. Similar >>>>>>>>>>>>> proofs with the
same conclusion are shown in other books, and some people >>>>>>>>>>>>> may find one
of them even easier to check.
What may need to an explanation is the exact meaning of the >>>>>>>>>>>>> conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only >>>>>>>>>>> "show"
that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics >>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>> simulated return statement while being simulated by HHH.
*If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually >>>>>>>>> from a
file or a set of files) and behaves as that C program specifies. >>>>>>>>> It is significantly less efficient than a compiler based
implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an >>>>>>>>> intermediate language that can be interpreted with a fast
interpreter
like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
Although I havn't worked woth any x86 since long ago I still know >>>>>>> quite a lot about it. But details of the machine code are irrelevant >>>>>>> to the genral topics discussed in comp.theory.
HHH works on the basis of the x86 code because the
x86 code provides a ready made directly graph of
all control flow. This same thing can be understood
much more easily at the C level is one knows C. If
one does not know C then they cannot possibly understand
what I am saying.
If you can express your claims so in a way that a respectable journal >>>>> accepts you will be understood. Otherwise it does not matter.
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
A mathematical proof is not exactly the same as an indoctrination
although they tend to have similar effects on peoples beliefs.
Some aspects of math do seem to be infallible.
The impression is misleading. Mathematicians check each others work
so errors can be detected and corrected before publication.
Things such as the principle of explosion and
Disjunction introduction are simply wrong headed.
No, they are not.
One just needs to understand them so that one does
not let them confuse and perhaps even can use them where they are
useful.
On 11/14/2026 3:01 AM, Mikko wrote:
On 13/11/2026 16:44, olcott wrote:
On 11/13/2026 3:10 AM, Mikko wrote:
On 12/11/2026 16:57, polcott wrote:
On 11/12/2026 3:12 AM, Mikko wrote:
On 11/11/2026 16:10, olcott wrote:
On 11/11/2026 3:13 AM, Mikko wrote:
On 10/11/2026 17:06, olcott wrote:
On 11/10/2026 2:18 AM, Mikko wrote:
On 31/10/2026 14:51, olcott wrote:
On 10/31/2026 3:12 AM, Mikko wrote:
On 30/10/2026 14:54, olcott wrote:
On 10/30/2026 4:04 AM, Mikko wrote:
On 29/10/2026 14:36, olcott wrote:
On 10/29/2026 3:45 AM, Mikko wrote:
On 24/10/2026 16:53, olcott wrote:It means isomorphic that means that the Linz proof >>>>>>>>>>>>>>> can be explained by my proof.
On 10/24/2026 2:55 AM, Mikko wrote:
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> On 10/1/26 5:28 PM, Chris M. Thomasson wrote: >>>>>>>>>>>>>>>>>>>>>>> On 10/1/2026 3:54 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>> [...]No, it isn't. The halting problem says nothing about >>>>>>>>>>>>>>>>>>>> "DD()" or "main()".
The key mistake of the halting theorem is that >>>>>>>>>>>>>>>>>>>>> it requires a halt decider to report on the behavior >>>>>>>>>>>>>>>>>>>>> of the direct execution of DD() from main() >>>>>>>>>>>>>>>>>>>>
Are you saying that the halting problem is not >>>>>>>>>>>>>>>>>>>>>>> solvable? If so, so what?
it is solvable for an enumerable set of machines >>>>>>>>>>>>>>>>>>>>>> that includes all possible output sequences, it is >>>>>>>>>>>>>>>>>>>>>> not solvable for all possible machines >>>>>>>>>>>>>>>>>>>>>
The halting problem asks "How can one determine >>>>>>>>>>>>>>>>>>>> whether a computation
halts?"
Here is the same thing from Linz where H and >>>>>>>>>>>>>>>>>>> -n.embedded_H are
also based on UTM simulation of their inputs. >>>>>>>>>>>>>>>>>>>
*From the bottom of page 319 has been adapted to this* >>>>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>>>>>>>
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I.e., there is nothing about "DD()" or "main()", just >>>>>>>>>>>>>>>>>> as I said.
Though Linz says nothing about "embedded_H", either; >>>>>>>>>>>>>>>>>> that is
your own interpolation. And you omitted important >>>>>>>>>>>>>>>>>> parts of the
definition.
-n.q0 rf?-nrf- // plays the same role as DD() executed from >>>>>>>>>>>>>>>>> main()
Having the same role does not mean being the same. >>>>>>>>>>>>>>>
There is no need to explain Linz's proof. Readers are >>>>>>>>>>>>>> assumed to already
know what a proof is (if necessary, they can find that in >>>>>>>>>>>>>> other boods).
It is easy to see that that proof is correct. Similar >>>>>>>>>>>>>> proofs with the
same conclusion are shown in other books, and some people >>>>>>>>>>>>>> may find one
of them even easier to check.
What may need to an explanation is the exact meaning of >>>>>>>>>>>>>> the conclusion.
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
I show that DD correctly simulated by HHH
cannot possibly reach its own final state.
In the other diecussions we have already noted tyat you only >>>>>>>>>>>> "show"
that with the fallacy of equivocation.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
DD simulated by HHH according to the operational semantics >>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>> *If you don't know what a C interpreter is then say so*
A C interpreter is a program that reads a C program (usually >>>>>>>>>> from a
file or a set of files) and behaves as that C program specifies. >>>>>>>>>> It is significantly less efficient than a compiler based
implementation
so rarely used if ever.
A more practical implementation is to translate a C program to an >>>>>>>>>> intermediate language that can be interpreted with a fast >>>>>>>>>> interpreter
like Java Virtual Machine.
The actual system uses x86 yet no one knows x86
so simply imagine what happens at the C level.
Although I havn't worked woth any x86 since long ago I still know >>>>>>>> quite a lot about it. But details of the machine code are
irrelevant
to the genral topics discussed in comp.theory.
HHH works on the basis of the x86 code because the
x86 code provides a ready made directly graph of
all control flow. This same thing can be understood
much more easily at the C level is one knows C. If
one does not know C then they cannot possibly understand
what I am saying.
If you can express your claims so in a way that a respectable journal >>>>>> accepts you will be understood. Otherwise it does not matter.
People have been indoctrinated into accepting the
Halting Theorem as equivalent to the infallible
word of God thus dismiss any challenges out-of-hand
without even glancing at the reasoning.
A mathematical proof is not exactly the same as an indoctrination
although they tend to have similar effects on peoples beliefs.
Some aspects of math do seem to be infallible.
The impression is misleading. Mathematicians check each others work
so errors can be detected and corrected before publication.
Unless the errors are so subtle that they cannot
be detected unless and until someone pays more
attention to the exact details than anyone ever
paid.
Things such as the principle of explosion and
Disjunction introduction are simply wrong headed.
No, they are not.
They are wrong headed because they violate the underlying
semantics.
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 55:54:25 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,712 |