• Re: Simulation trace of a simple C function

    From olcott@polcott333@gmail.com to comp.theory,sci.logic on Thu Nov 12 12:48:37 2026
    From Newsgroup: sci.logic

    On 11/12/2026 9:34 AM, Alan Mackenzie wrote:
    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.


    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. Thus when a machine is asked
    Is this sentence true or false: "This sentence is not true"
    it has no correct yes/no answer.

    As I established back in 2015
    The logical law of polar questions https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ
    Yes/No questions lacking a correct Yes/No answer are
    incorrect polar questions.

    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

    --
    Copyright 2026 Olcott

    Computation(Olcott)
    Paraphrase of Emil Post definition of computation
    All computations are equivalent to the application of finite
    string transformation rules to finite string inputs to derive
    any and all outputs.

    Because Post canonical systems are Turing-equivalent, anything
    that cannot be derived by applying finite string transformations
    to finite strings is outside the scope of ChurchrCoTuring computation.

    Decider(Olcott)
    Correcting the misnomer term-of-the-art: decider
    Every Decider(Olcott) must apply finite string transformation
    inference steps to their finite string inputs that are relevant
    to the decision criteria. It must make its decision on this basis.

    Halt Decider(Olcott)
    Decider(Olcott) entails that Halt Decider(Olcott) H(D) must apply
    finite-string inference steps according to the operational semantics
    of the source-code computation language of D. The only way to determine
    the halting property of a finite string input is to examine the same
    behavior as the behavior of D simulated by H.

    *Succinct refutation of the Halting Theorem* https://github.com/plolcott/x86utm/blob/master/README.md

    My 28 year goal has been to make
    "true on the basis of meaning expressed in language"
    reliably computable for the entire body of general knowledge.
    The complete structure of this system is now defined.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Alan Mackenzie@acm@muc.de to comp.theory,sci.logic on Thu Nov 12 19:30:36 2026
    From Newsgroup: sci.logic

    [ 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
    --
    Alan Mackenzie (Nuremberg, Germany).

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Thu Nov 12 14:04:29 2026
    From Newsgroup: sci.logic

    On 11/12/2026 1:30 PM, Alan Mackenzie wrote:
    [ 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.


    Anything that cannot be computed by applying finite
    string transformation rules to finite string inputs
    is outside the scope of Turing computable functions
    the same way that filling your tires with air it
    outside the scope of your toaster.

    Unless we pay attention to the underlying details
    of this there is no way to segregate what is
    uncomputable because it is too difficult to compute
    from what is uncomputable because it is outside
    of the scope of Turing computable functions.


    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

    --
    Copyright 2026 Olcott

    Computation(Olcott)
    Paraphrase of Emil Post definition of computation
    All computations are equivalent to the application of finite
    string transformation rules to finite string inputs to derive
    any and all outputs.

    Because Post canonical systems are Turing-equivalent, anything
    that cannot be derived by applying finite string transformations
    to finite strings is outside the scope of ChurchrCoTuring computation.

    Decider(Olcott)
    Correcting the misnomer term-of-the-art: decider
    Every Decider(Olcott) must apply finite string transformation
    inference steps to their finite string inputs that are relevant
    to the decision criteria. It must make its decision on this basis.

    Halt Decider(Olcott)
    Decider(Olcott) entails that Halt Decider(Olcott) H(D) must apply
    finite-string inference steps according to the operational semantics
    of the source-code computation language of D. The only way to determine
    the halting property of a finite string input is to examine the same
    behavior as the behavior of D simulated by H.

    *Succinct refutation of the Halting Theorem* https://github.com/plolcott/x86utm/blob/master/README.md

    My 28 year goal has been to make
    "true on the basis of meaning expressed in language"
    reliably computable for the entire body of general knowledge.
    The complete structure of this system is now defined.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Fri Nov 13 08:44:19 2026
    From Newsgroup: sci.logic

    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:
    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.

    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.
    --
    Copyright 2026 Olcott

    Computation(Olcott)
    Paraphrase of Emil Post definition of computation
    All computations are equivalent to the application of finite
    string transformation rules to finite string inputs to derive
    any and all outputs.

    Because Post canonical systems are Turing-equivalent, anything
    that cannot be derived by applying finite string transformations
    to finite strings is outside the scope of ChurchrCoTuring computation.

    Decider(Olcott)
    Correcting the misnomer term-of-the-art: decider
    Every Decider(Olcott) must apply finite string transformation
    inference steps to their finite string inputs that are relevant
    to the decision criteria. It must make its decision on this basis.

    Halt Decider(Olcott)
    Decider(Olcott) entails that Halt Decider(Olcott) H(D) must apply
    finite-string inference steps according to the operational semantics
    of the source-code computation language of D. The only way to determine
    the halting property of a finite string input is to examine the same
    behavior as the behavior of D simulated by H.

    *Succinct refutation of the Halting Theorem* https://github.com/plolcott/x86utm/blob/master/README.md

    My 28 year goal has been to make
    "true on the basis of meaning expressed in language"
    reliably computable for the entire body of general knowledge.
    The complete structure of this system is now defined.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to comp.theory,sci.logic on Sat Nov 14 11:01:58 2026
    From Newsgroup: sci.logic

    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:
    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.

    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.
    --
    Mikko

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to sci.logic,comp.theory on Sat Nov 14 07:08:23 2026
    From Newsgroup: sci.logic

    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:
    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.

    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. They violate the underlying semantics because
    reasoning was divided into syntax and semantics was removed
    and handled separately. A number of authors fixed this
    stupid mistake.

    William Parry (Analytic Implication, 1933)
    Imposing Relevance Constraints (Relevance Logic)
    A contradiction semantically entails reN falsum and out
    of falsum nothing comes.

    One just needs to understand them so that one does
    not let them confuse and perhaps even can use them where they are
    useful.


    In my system semantic entailment specified syntactically
    is the only inference step allowed.
    --
    Copyright 2026 Olcott

    Computation(Olcott)
    Paraphrase of Emil Post definition of computation
    All computations are equivalent to the application of finite
    string transformation rules to finite string inputs to derive
    any and all outputs.

    Because Post canonical systems are Turing-equivalent, anything
    that cannot be derived by applying finite string transformations
    to finite strings is outside the scope of ChurchrCoTuring computation.

    Decider(Olcott)
    Correcting the misnomer term-of-the-art: decider
    Every Decider(Olcott) must apply finite string transformation
    inference steps to their finite string inputs that are relevant
    to the decision criteria. It must make its decision on this basis.

    Halt Decider(Olcott)
    Decider(Olcott) entails that Halt Decider(Olcott) H(D) must apply
    finite-string inference steps according to the operational semantics
    of the source-code computation language of D. The only way to determine
    the halting property of a finite string input is to examine the same
    behavior as the behavior of D simulated by H.

    *Succinct refutation of the Halting Theorem* https://github.com/plolcott/x86utm/blob/master/README.md

    My 28 year goal has been to make
    "true on the basis of meaning expressed in language"
    reliably computable for the entire body of general knowledge.
    The complete structure of this system is now defined.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to sci.logic,comp.theory on Sun Nov 15 11:49:50 2026
    From Newsgroup: sci.logic

    On 14/11/2026 15:08, olcott wrote:
    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:
    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.

    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.

    Occasionally such subtle errors have been detected but not often.
    For example, Euclid thought that if the ceter of one circle is
    at the circumference of another then those two cirecles intersect.
    But he did not prove it and did not notice that he cannot prove it
    from his axioms and postulates.

    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.

    They don't. The intended semantics is that the conclusion is true
    whenever every premise is true, i.e., if the conclusion is false
    then at least one of the premises is false. Both the priciple of
    explosion and disjunction induction satisfy this requirement. But
    neither of them is necessary. You can always use tautologies and
    modus ponens instead.
    --
    Mikko

    --- Synchronet 3.22a-Linux NewsLink 1.2