• Re: Church-Turing and computable functions

    From olcott@polcott333@gmail.com to sci.math,comp.theory,sci.logic,comp.ai.philosophy on Sat Oct 3 06:57:12 2026
    From Newsgroup: comp.ai.philosophy

    On 10/3/2026 5:02 AM, Python wrote:
    Now the disagreement is completely explicit.

    You say:

    -a-a Nothing because the whole recursive chain has been aborted.

    That is precisely the problem.

    If HHH aborts the entire simulated computation, then it has not
    established that DD itself specifies a non-halting computation. It has established that the particular simulation procedure being performed by
    HHH would recurse indefinitely unless HHH intervenes.


    Yes that is true. In the first case we violate the Emil Post
    Turing Equivalent notion that all computation is essentially
    applying finite string transformation rules to finite string
    inputs to derive any and all outputs.

    The second case does not violate this.

    Those are different propositions.

    Consider your quoted statement:

    -a-a If simulating halt decider H correctly simulates its
    -a-a input D until H correctly determines that its simulated D
    -a-a would never stop running unless aborted then

    -a-a H can abort its simulation of D and correctly report that D
    -a-a specifies a non-halting sequence of configurations.

    I have no objection to that statement as written.

    The crucial phrase is:

    -a-a correctly determines


    // line 1012
    https://github.com/plolcott/x86utm/blob/master/Halt7.c
    u32 Needs_To_Be_Aborted_HH(Decoded_Line_Of_Code* execution_trace)

    You already agreed that it would be correct.
    On 10/2/2026 6:57 PM, Python wrote:
    HHH simulates DD
    DD calls HHH(DD)
    HHH simulates DD
    DD calls HHH(DD)
    HHH simulates DD
    ...

    Therefore the simulated DD never gets past line 03.

    I agree.


    That phrase assumes the very thing that must be proved.

    For an ordinary infinite loop such as:

    -a-a D()
    -a-a {
    -a-a-a-a-a-a while (1) {}
    -a-a }

    H may have some sound method proving that D specifies a non-halting computation.

    But DD is different because the behavior of DD depends on the result returned by HHH(DD).

    You cannot establish that DD is non-halting merely by observing that recursive simulation occurs when HHH attempts to simulate DD. You must establish that the actual computation specified by DD is non-halting.

    And this brings us directly to your second claim:

    -a-a When HHH is called from DD() this is not the input
    -a-a finite string to HHH and HHH is only accountable
    -a-a Emil Post computations.

    This does not solve the problem.

    The source text or machine description of DD is a finite string.

    The description of HHH is also a finite string.

    The configuration representing:

    -a-a DD executing line 03 and invoking HHH(DD)

    is finite.

    The next configuration is finite.

    Every individual configuration in the recursive computation is finite.

    Every transition between configurations is determined by finite rules.

    Thus:

    -a-a DD -> HHH(DD) -> simulated DD -> simulated HHH(DD) -> ...

    This is simply not what HHH sees.
    This is what HHH(DD) (no matter who calls it) sees

    On 10/2/2026 6:57 PM, Python wrote:
    HHH simulates DD
    DD calls HHH(DD)
    HHH simulates DD
    DD calls HHH(DD)
    HHH simulates DD
    ...


    is perfectly representable as a sequence of finite configurations
    generated by finite transition rules.

    The fact that the sequence may be infinite does not violate Post's formulation.


    Yet H correctly determines that its simulated D
    would never stop running unless aborted ...

    That distinction is essential.

    "Finite string transformations" does NOT mean that every computation
    must contain only finitely many transformations.

    It means that computation proceeds by finitely specified operations on finite symbolic configurations.

    A Turing machine that runs forever is still a Turing-machine computation.

    Likewise, an infinite Post production sequence does not suddenly become something outside computation theory merely because it has infinitely
    many successive configurations.

    Otherwise the halting problem would become meaningless by definition:
    every non-halting computation would simply be declared "outside the
    scope" because it contains infinitely many steps.

    There is an even more fundamental problem with saying:

    -a-a All of it seems to be referring to DD() calling HHH
    -a-a and this violates Emil Post.

    DD calling HHH cannot simultaneously be:


    int main()
    {
    DD(); // calling HHH is not what HHH actually sees
    }

    This is what HHH actually sees no matter who invokes it.
    On 10/2/2026 6:57 PM, Python wrote:
    HHH simulates DD
    DD calls HHH(DD)
    HHH simulates DD
    DD calls HHH(DD)
    HHH simulates DD
    ...

    HHH correctly determines that its simulated DD
    would never stop running unless aborted ...

    1. forbidden as something outside the computational model,

    and

    2. something HHH correctly simulates according to the operational
    semantics of C.

    Your own simulation trace contains exactly that call:

    -a-a simulated DD()
    -a-a-a-a-a-a invokes simulated HHH(DD)

    You used that transition to establish your invariant:

    -a-a DD correctly simulated by HHH cannot possibly
    -a-a reach past its own line 03.

    So the call cannot suddenly become inadmissible when we ask what follows from it.

    If:

    -a-a simulated DD -> simulated HHH(DD)

    is a legitimate transition when establishing your invariant, then it
    remains a legitimate transition when analyzing what HHH's answer means.

    There is also a deeper issue with:

    -a-a Nothing because the whole recursive chain has been aborted.

    Suppose HHH reaches some finite configuration C and recognizes the
    recursive pattern.

    HHH then performs an operation such as:

    -a-a abort simulation;
    -a-a return 0;

    Fine. That is itself just another finite computational transition.

    Now ask what proposition the returned 0 asserts.

    If it asserts:

    -a-a "The simulation I just aborted would have continued recursively"

    then I agree.

    But that is not a solution to the halting problem.


    <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its
    input D until H correctly determines that its simulated D
    would never stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
    </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

    The best selling author of theory of computation textbooks agrees
    with the above. It has been verified that he really said this.

    A halt decider must answer the relevant question about its input computation:

    -a-a "Does the computation specified by DD halt?"


    That is ambiguous. It is more correctly stated as:
    Does the finite string input DD to HHH specify a finite
    sequence of configurations that will terminate normally
    without needing to be aborted?

    If 0 means:

    -a-a "DD does not halt"

    then the answer must correspond to the semantics of DD.


    HHH1(DD) and HHH(DD) (also contained in my code) shows that
    DD within pathological self-reference (PSR) does have different
    behavior than DD without (PSR). HHH is only accountable for
    the actual behavior that it actually sees. HHH is not accountable
    for behavior that people expect that it should look at.

    And DD contains:

    -a-a Halt_Status = HHH(DD);

    Therefore the value returned by HHH is semantically relevant to DD's behavior.

    You cannot say both:

    -a-a HHH returns 0 as the answer about DD

    and:

    -a-a DD never receives that 0 because I aborted DD.

    The latter describes what HHH did to

    the application of correct finite string transformation
    inference rules to its input DD.

    its private simulation.

    It does not establish what DD does when HHH returns 0.


    int main()
    {
    DD(); // is not what HHH actually sees.
    }

    This is the distinction between:

    -a-a aborting a simulation of P


    See Sipser.

    and:

    -a-a proving that P itself does not halt.

    For example, I can write a simulator S that simulates any program for
    1000 steps and then aborts.


    This would require a conditional branch that HHH
    verifies does not exist.

    When S aborts the simulation of P, obviously P does not receive anything from S.

    But that tells us absolutely nothing about whether P itself would
    eventually halt.


    When HHH sees a conditional branch then HHH does not abort.

    Your proposed HHH needs something stronger: a sound criterion proving
    that the aborted infinite-looking simulation corresponds to a genuinely non-halting computation of DD.


    It does do this for its entire limited domain.

    And with DD, that is exactly where diagonalization matters.

    If HHH returns "non-halting", DD is defined to take the non-looping branch.

    If HHH returns "halting", DD is defined to take the looping branch.


    You keep ignoring the Sipser approved criteria.

    Aborting HHH's internal simulation does not remove this semantic
    dependency.

    It merely prevents the simulated copy from continuing.

    So I think we have finally isolated the exact issue.

    I agree that HHH may abort its own simulation.

    I agree that the recursive simulation, if allowed to continue, produces
    an unbounded sequence of nested simulations.

    I agree that HHH can detect some such patterns if you provide an
    effective detection rule.

    What has not been established is the following implication:

    -a-a "HHH's simulation of DD would recurse forever"


    "never stop running unless aborted" is the actual criteria.
    It took me two years to come up with that exact paragraph
    pair. I had professor Sipser's phone number the whole time.
    I only contacted him when I knew that I was correct after
    many hundreds of rewrites.

    therefore

    -a-a "DD specifies a non-halting computation"

    because DD's behavior depends on the answer produced by HHH.

    And appealing to Emil Post does not eliminate that dependency. The
    source of DD, the source of HHH, every configuration involved, and every individual transition are all finite symbolic objects governed by finite rules.


    My system does exactly what professor Sipser agreed is correct.
    The halting problem proof requires a result that cannot be
    attained by applying correct finite string transformation
    rules to input finite strings.

    So there is now one very precise question:

    When HHH aborts the recursive simulation and reports "DD does not halt", what finite-string computation establishes that this statement is about
    the behavior specified by DD, rather than merely about the
    nontermination of the simulation that HHH has just aborted?

    That is the missing step.

    HHH does correctly determine that its input DD does
    specify a non-halting sequence of configurations if

    (a) The words Professor Sipser agreed to are correct

    (b) HHH derives this result by the application of
    correct finite string transformation rules to its input.
    --
    Copyright 2026 Olcott

    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.

    The entire body of knowledge expressed in language is
    comprised of two types of relations between finite strings:
    (a) *Axioms* Expressions of language that are stipulated to be true.

    My system bridges the analytic/synthetic distinction by
    expressly encoding all empirical "atomic facts" in a formal
    language such as CycL of the Cyc project.

    (b) *Inference Rules* Expressions of language that are semantically
    entailed syntactically from (a) and/or (b).
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to comp.theory,sci.logic,sci.math,sci.math.symbolic,comp.ai.philosophy on Wed Oct 7 13:40:11 2026
    From Newsgroup: comp.ai.philosophy

    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?"
    --
    Mikko
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to sci.math,sci.logic,sci.math.symbolic,comp.theory,comp.ai.philosophy on Wed Oct 7 13:46:04 2026
    From Newsgroup: comp.ai.philosophy

    On 02/10/2026 17:15, olcott wrote:
    On 10/2/2026 8:58 AM, Python wrote:
    Le 02/10/2026 |a 15:56, olcott a |-crit :
    On 10/2/2026 8:32 AM, Python wrote:
    Le 02/10/2026 |a 15:24, olcott a |-crit :
    On 10/2/2026 7:59 AM, Python wrote:
    Le 02/10/2026 |a 14:28, olcott a |-crit :
    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()

    https://github.com/plolcott/x86utm/blob/master/README.md
    This is outside of the Church-Turing scope when this scope
    is understood to only allow finite string transformation
    rules to be applied to finite string inputs to derive any
    any all outputs.

    The only correct finite string transformation rules that
    HHH is allowed to apply to its finite string input DD are
    specified by the operational semantics of the C programming
    language.

    There are no correct finite string transformation rules that
    HHH can possibly apply to its input finite string that derive
    the behavior of DD directly executed in main().

    Peter, this distinction between "the operational semantics of C"
    and "the behavior of DD directly executed from main()" does not
    exist.


    Counter-factual you just did not pay close enough
    attention and merely leaped to a false conclusion.

    Peter, saying "counter-factual" is not a counterargument.

    It has taken me many thousands of hours very carefully
    compose the few words that I just said. Carefully
    study them for a few hours until you fully understand
    every subtle nuance of every single detail before you
    reply.

    Peter, the number of hours you spent composing a statement has no
    bearing on whether it is true.

    That is true, None-the-less I will no longer
    tolerate people that glance at a couple of
    my words before artificially contriving a
    rebuttal that conclusively proves that they
    did not bother to pay complete attention
    to every detail of what I said.

    So you are not going to tolerate reasonable people that are not stupid
    enough for your bluff. If one detail of your prosentation is wrong or incomplete or missing it is important to focus on that and not care
    about the rest.
    --
    Mikko
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From polcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Oct 7 07:25:59 2026
    From Newsgroup: comp.ai.philosophy

    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

    *Keeps repeating unless aborted*
    (a) -n copies its input rf?-nrf-
    (b) -n invokes embedded_H rf?-nrf- rf?-nrf-
    (c) embedded_H simulates rf?-nrf- rf?-nrf-

    The key mistake of the Peter Linz Halting Problem proof is that
    embedded_H is required to report on the behavior of -n applied
    to rf?-nrf- (the computation that embedded_H is embedded within)
    if -n applied to rf?-nrf- halts, and
    if -n applied to rf?-nrf- does not halt

    instead of the behavior specified by its own input finite string rf?-nrf-.

    <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its
    input D until H correctly determines that its simulated D
    would never stop running unless aborted then

    H can abort its simulation of D and correctly report that
    [the correctly simulated] D specifies a non-halting
    sequence of configurations.
    </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    [the correctly simulated] // inserted for clarity
    it can already be inferred from the context.

    https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
    --
    Copyright 2026 Olcott

    The essence of computation is applying finite
    string transformations to finite string inputs
    to derive outputs. // paraphrase of Emil Post

    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.

    The entire body of knowledge expressed in language is
    comprised of two types of relations between finite strings:
    (a) *Axioms* Expressions of language that are stipulated to be true.

    My system bridges the analytic/synthetic distinction by
    expressly encoding all empirical "atomic facts" in a formal
    language such as CycL of the Cyc project.

    (b) *Inference Rules* Expressions of language that are semantically
    entailed syntactically from (a) and/or (b).
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,sci.math,sci.math.symbolic on Wed Oct 7 08:07:07 2026
    From Newsgroup: comp.ai.philosophy

    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

    *Keeps repeating unless aborted*
    (a) -n copies its input rf?-nrf-
    (b) -n invokes embedded_H rf?-nrf- rf?-nrf-
    (c) embedded_H simulates rf?-nrf- rf?-nrf-

    The key mistake of the Peter Linz Halting Problem proof is that
    embedded_H is required to report on the behavior of -n applied
    to rf?-nrf- (the computation that embedded_H is embedded within)
    if -n applied to rf?-nrf- halts, and
    if -n applied to rf?-nrf- does not halt

    instead of the behavior specified by its own input finite string rf?-nrf-.

    <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its
    input D until H correctly determines that its simulated D
    would never stop running unless aborted then

    H can abort its simulation of D and correctly report that
    [the correctly simulated] D specifies a non-halting
    sequence of configurations.
    </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    [the correctly simulated] // inserted for clarity
    it can already be inferred from the context.

    https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
    --
    Copyright 2026 Olcott

    The essence of computation is applying finite
    string transformations to finite string inputs
    to derive outputs. // paraphrase of Emil Post

    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.

    The entire body of knowledge expressed in language is
    comprised of two types of relations between finite strings:
    (a) *Axioms* Expressions of language that are stipulated to be true.

    My system bridges the analytic/synthetic distinction by
    expressly encoding all empirical "atomic facts" in a formal
    language such as CycL of the Cyc project.

    (b) *Inference Rules* Expressions of language that are semantically
    entailed syntactically from (a) and/or (b).
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to comp.theory,sci.logic,comp.ai.philosophy on Fri Oct 9 11:18:51 2026
    From Newsgroup: comp.ai.philosophy

    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*

    Earlier on that page Linz says: "Simply stated, the problem is: given
    the description of a Turing machine M and an input w, does M, when
    started in the initial configuration qow, perform a computation that
    eventually halts?"

    At the bottom of the page, continuing to the next page, is a formal
    definition of the solution of the halting problem, which Linz defines
    as a Turing machine.

    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

    There is no "embedded_H" in Linz's definition.
    --
    Mikko
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to comp.theory,sci.logic,comp.ai.philosophy,sci.math,sci.math.symbolic on Sat Oct 10 11:35:38 2026
    From Newsgroup: comp.ai.philosophy

    On 07/10/2026 16:07, olcott 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*

    Irrelevant. Halting problem is introduced and defined on the page 317
    and the top of page 318. Everything under the title "Theorem 12.1" and
    later is irrelevant to our current topic.
    --
    Mikko
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,sci.math on Sat Oct 10 14:57:18 2026
    From Newsgroup: comp.ai.philosophy

    On 10/10/2026 3:31 AM, Mikko wrote:
    On 09/10/2026 14:40, olcott wrote:
    On 10/9/2026 3:18 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*

    Earlier on that page Linz says: "Simply stated, the problem is: given
    the description of a Turing machine M and an input w, does M, when
    started in the initial configuration qow, perform a computation that
    eventually halts?"

    At the bottom of the page, continuing to the next page, is a formal
    definition of the solution of the halting problem, which Linz defines
    as a Turing machine.

    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

    There is no "embedded_H" in Linz's definition.


    <Linz text>
    -aFrom H' we construct another Turing machine -n.

    That is later in the text, not in the definition 12.1, so irrelevant
    to this discussion.


    I am ONLY talking about the Linz machine that totally
    implements the Halting Problem counter-example input.

    https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

    *From the bottom of page 319*
    q0 Wm Wm reo* -nq0 Wm Wm reo* -n.reR // accept state
    q0 Wm Wm reo* -nq0 Wm Wm reo* -n.qn // reject state

    Linz encodes his embedding of his machine H: -nq0
    Linz calls the finite string input to -n: Wm

    *the bottom of page 319 has been adapted to this*
    -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

    rf?-nrf- more conventionally shows that -n is taking its
    own finite string machine description as its input.
    --
    Copyright 2026 Olcott

    The essence of computation is applying finite
    string transformations to finite string inputs
    to derive outputs. // paraphrase of Emil Post

    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.

    The entire body of knowledge expressed in language is
    comprised of two types of relations between finite strings:
    (a) *Axioms* Expressions of language that are stipulated to be true.

    My system bridges the analytic/synthetic distinction by
    expressly encoding all empirical "atomic facts" in a formal
    language such as CycL of the Cyc project.

    (b) *Inference Rules* Expressions of language that are semantically
    entailed syntactically from (a) and/or (b).
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to comp.theory,sci.logic,comp.ai.philosophy on Sat Oct 24 10:55:36 2026
    From Newsgroup: comp.ai.philosophy

    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.

    *Keeps repeating unless aborted*
    (a) -n copies its input rf?-nrf-
    (b) -n invokes embedded_H rf?-nrf- rf?-nrf-
    (c) embedded_H simulates rf?-nrf- rf?-nrf-

    No, that is not a part of the definition. And not a part of anything
    else in Linz's book, either.
    --
    Mikko
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to comp.theory,sci.logic,comp.ai.philosophy,sci.math,sci.math.symbolic on Sun Oct 25 11:56:51 2026
    From Newsgroup: comp.ai.philosophy

    On 07/10/2026 16:07, olcott 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

    The bottom of the page 319 is not a part of and not relevant to how
    Linz has already defined the haliting problem on pages 317-318.

    Consequently, your false claims about the content of the page 319
    are irrlevant, too.
    --
    Mikko
    --- Synchronet 3.22a-Linux NewsLink 1.2