• Correcting the errors in the foundation of computation

    From olcott@polcott333@gmail.com to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 23 13:10:12 2026
    From Newsgroup: comp.ai.philosophy

    These terms are replaced:
    (a) "Turing machine description" is replaced with
    [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    steps that are applied to an input static finite string
    that are syntactically or semantically relevant to the
    decision criteria.

    Concrete example of a decider where relevance is required.
    int strcmp(const char *str1, const char *str2);
    and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.
    --
    Copyright 2026 Olcott

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


    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 23 13:11:59 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-10-23 12:10, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps. >
    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    The term 'description' as using in computational theory normally refers
    to a 7-tuple as described here:

    <https://en.wikipedia.org/wiki/Turing_machine#Formal_definition>

    How is that any more vague that your alternative? Note also that the
    term 'source code' isn't normally used for Turing Machines since Turing Machines are mathematical objects, not things that are compiled to run
    on digital computers.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a steps that are applied to an input static finite string
    -a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a decision criteria.

    -a-a-a-a Concrete example of a decider where relevance is required.
    -a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a and the finite string inputs are the entire basis.

    strcmp() isn't a decider at all. A decider takes a single input and
    either accepts it or rejects it. It is an algorithm implementing the membership function of a set.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    Since your example isn't a decider, it rather difficult to see how your
    claims somehow 'tightens' the term.

    Andr|-
    --
    To email remove 'invalid' & replace 'gm' with well known Google mail
    service.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 23 14:31:06 2026
    From Newsgroup: comp.ai.philosophy

    On 10/23/2026 2:11 PM, Andr|- G. Isaak wrote:
    On 2026-10-23 12:10, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps. >
    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    The term 'description' as using in computational theory normally refers
    to a 7-tuple as described here:

    <https://en.wikipedia.org/wiki/Turing_machine#Formal_definition>

    How is that any more vague that your alternative? Note also that the
    term 'source code' isn't normally used for Turing Machines since Turing Machines are mathematical objects, not things that are compiled to run
    on digital computers.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string
    -a-a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required.
    -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis.

    strcmp() isn't a decider at all. A decider takes a single input and
    either accepts it or rejects it. It is an algorithm implementing the membership function of a set.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    Since your example isn't a decider, it rather difficult to see how your claims somehow 'tightens' the term.

    Andr|-


    Nit-picky irrelevant details. The idea was to show
    that the decision criteria restricts the steps to
    those that are syntactically relevant.

    This is a key missing element of the foundations
    of computation that prevents computation from being
    understood more deeply.
    --
    Copyright 2026 Olcott

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


    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 Python@python@cccp.invalid to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 23 21:16:40 2026
    From Newsgroup: comp.ai.philosophy

    Nit-picky irrelevant details. The idea was to show
    that the decision criteria restricts the steps to
    those that are syntactically relevant.

    This is a key missing element of the foundations
    of computation that prevents computation from being
    understood more deeply.

    No, Peter.

    That is not a "missing element of the foundations of computation."

    That is a new restriction you have just invented.

    You started with:

    computation operates on finite strings

    which nobody disputes.

    You have now silently strengthened that into:

    computation may use only steps that Peter declares
    "syntactically relevant" to the decision criterion.

    Those propositions are not remotely equivalent.

    Post's characterization of effective computation does not give you a
    magical "relevance" filter that permits a purported decider to ignore consequences of its own result.

    And `strcmp()` proves nothing of the sort.

    It merely computes a particular function of two finite strings.

    More importantly, Andr|-'s objection is not "nit-picky."

    You are claiming to have discovered an error in the foundations of computability while simultaneously redefining its basic terms.

    When someone points out that your example is not even a decider in the standard technical sense, answering:

    "irrelevant details"

    is rather spectacular.

    Definitions ARE the details when your claimed revolution consists of
    changing definitions.

    And now we have yet another newly introduced term:

    "syntactically relevant"

    Please define it mathematically.

    Then prove your claimed theorem:

    A decision procedure may consider only
    syntactically relevant inference steps.

    In particular, define "relevant" without circularly meaning:

    whatever allows HHH to return the answer
    Peter wants while ignoring the consequence
    that makes that answer wrong.

    Because until you do that, you have not discovered a missing foundation of computation.

    You have invented an undefined restriction and declared it foundational.

    That is not deeper understanding.

    That is moving the goalposts and giving the new goalpost a name.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Mikko@mikko.levanto@iki.fi to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Mon Oct 26 11:23:48 2026
    From Newsgroup: comp.ai.philosophy

    It does not make sense to correct an error before an error is identified
    and analyzed.

    On 23/10/2026 21:10, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a [Finite string source code for a Turing Machine]

    That does not make sense without a definition on "source code" in the
    context of Turing machines. A description can be required to have the
    form that can be used for a particular purpose but the term "source
    code" does not unless so defined earlier in the same opus.

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term "source code" is even more vague. It does even permit to
    require that the code can be used for the intended purpose. The
    term "description" permits additional restrictions that ensure its
    usefulness.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    The term "mahicne description" may mean 'a description of a machine'
    or the same as "machine readable description", possibly also the
    same as "description written by a machine".

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a steps that are applied to an input static finite string
    -a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a decision criteria.

    That does not make clear what the replacement is. Anyway, the term
    "decider" has a clear meaning. There is no need to replace it when
    that meaning is needed. If a little different meaning is wanted then
    some adjective can be added, e.g. "partial decider". For other
    meanings other words can be used but that hardly counts as a
    replacement.

    -a-a-a-a Concrete example of a decider where relevance is required.
    -a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a and the finite string inputs are the entire basis.

    THe usual meaning of strcmp is that it can give three different
    answers (whether str1 is less, equal, or greater than str2), so
    it is not a decider, which can only give two different values.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated.

    The exact meaning of "decider" is given in texbooks and is therefore
    well known and need'n be defined in every opus using it.

    We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.

    No, you havn't. The choice of the terms is not what foundations is.
    Foundation of the computation is the identification of a set of
    opterations that is both simple enough that it is obvious that they
    can be performed and powerful enough that all computations can be
    computed without any other operations.
    --
    Mikko
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Johann 'Myrkraverk' Oskarsson@johann@myrkraverk.invalid to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 30 23:06:45 2026
    From Newsgroup: comp.ai.philosophy

    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a steps that are applied to an input static finite string
    -a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a decision criteria.

    -a-a-a-a Concrete example of a decider where relevance is required.
    -a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.



    What exactly executes the new and corrected errors of computation?

    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right? Wrong? How can you
    -- not -- execute code with a Turing-machine? What else is there?
    --
    Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
    I'm not from the Internet, I just work there. | via Easynews.com https://bsky.app/profile/myrkraverk.bsky.social | for ( ;; ) _:;
    Federated at https://fed.brid.gy/bsky/myrkraverk.bsky.social
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 30 10:11:07 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string
    -a-a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required.
    -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.



    What exactly executes the new and corrected errors of computation?

    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right?-a Wrong?-a How can you
    -- not -- execute code with a Turing-machine?-a What else is there?

    Because Post canonical systems are Turing equivalent anything
    that cannot be derived by applying finite string transformations
    to finite strings is outside of the scope of computation.
    --
    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 of the scope of 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. These inference
    steps must correctly determine the behavior specified by D.
    H must make its halting decision on this basis.

    *Succinct refutation of the Halting Theorem* https://github.com/plolcott/x86utm/blob/master/README.md
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Johann 'Myrkraverk' Oskarsson@johann@myrkraverk.invalid to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Sat Oct 31 00:02:01 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/2026 11:11 PM, olcott wrote:
    On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string
    -a-a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required.
    -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.



    What exactly executes the new and corrected errors of computation?

    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right?-a Wrong?-a How can you
    -- not -- execute code with a Turing-machine?-a What else is there?

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


    Ok, so show me your finite string machine! Don't be shy. I don't mind
    raw electronics.

    Now go!
    --
    Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
    I'm not from the Internet, I just work there. | via Easynews.com https://bsky.app/profile/myrkraverk.bsky.social | for ( ;; ) _:;
    Federated at https://fed.brid.gy/bsky/myrkraverk.bsky.social
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 30 11:14:01 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/30/2026 11:11 PM, olcott wrote:
    On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string
    -a-a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required.
    -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.



    What exactly executes the new and corrected errors of computation?

    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right?-a Wrong?-a How can you
    -- not -- execute code with a Turing-machine?-a What else is there?

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


    Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind
    raw electronics.

    Now go!

    https://github.com/plolcott/x86utm/blob/master/README.md
    --
    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 of the scope of 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. These inference
    steps must correctly determine the behavior specified by D.
    H must make its halting decision on this basis.

    *Succinct refutation of the Halting Theorem* https://github.com/plolcott/x86utm/blob/master/README.md
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Johann 'Myrkraverk' Oskarsson@johann@myrkraverk.invalid to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Sat Oct 31 00:50:02 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 12:14 AM, olcott wrote:
    On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/30/2026 11:11 PM, olcott wrote:
    On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string
    -a-a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required. >>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.



    What exactly executes the new and corrected errors of computation?

    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right?-a Wrong?-a How can you
    -- not -- execute code with a Turing-machine?-a What else is there?

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


    Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind
    raw electronics.

    Now go!

    https://github.com/plolcott/x86utm/blob/master/README.md


    That's just words on a screen. I was expecting a physical machine. Are
    you lazy or something? Is there something wrong with a physical string transformation machine?

    Surely you can build a small one with 74xx logic chips?
    --
    Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
    I'm not from the Internet, I just work there. | via Easynews.com https://bsky.app/profile/myrkraverk.bsky.social | for ( ;; ) _:;
    Federated at https://fed.brid.gy/bsky/myrkraverk.bsky.social
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 30 11:53:15 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/2026 11:50 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/31/2026 12:14 AM, olcott wrote:
    On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/30/2026 11:11 PM, olcott wrote:
    On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string >>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.



    What exactly executes the new and corrected errors of computation?

    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right?-a Wrong?-a How can you
    -- not -- execute code with a Turing-machine?-a What else is there?

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


    Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind >>> raw electronics.

    Now go!

    https://github.com/plolcott/x86utm/blob/master/README.md


    That's just words on a screen.-a I was expecting a physical machine.-a Are you lazy or something?-a Is there something wrong with a physical string transformation machine?

    Surely you can build a small one with 74xx logic chips?

    x86utm is a minimal operating system that I wrote
    that implements HHH/DD as fully operational code.
    --
    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Johann 'Myrkraverk' Oskarsson@johann@myrkraverk.invalid to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Sat Oct 31 00:54:25 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 12:53 AM, olcott wrote:
    On 10/30/2026 11:50 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/31/2026 12:14 AM, olcott wrote:
    On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/30/2026 11:11 PM, olcott wrote:
    On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string >>>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the >>>>>>> -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.



    What exactly executes the new and corrected errors of computation? >>>>>>
    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right?-a Wrong?-a How can you >>>>>> -- not -- execute code with a Turing-machine?-a What else is there? >>>>>
    Because Post canonical systems are Turing equivalent anything
    that cannot be derived by applying finite string transformations
    to finite strings is outside of the scope of computation.


    Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind >>>> raw electronics.

    Now go!

    https://github.com/plolcott/x86utm/blob/master/README.md


    That's just words on a screen.-a I was expecting a physical machine.-a Are >> you lazy or something?-a Is there something wrong with a physical string
    transformation machine?

    Surely you can build a small one with 74xx logic chips?

    x86utm is a minimal operating system that I wrote
    that implements HHH/DD as fully operational code.


    But it's not a physical machine of your design. It's merely an x86 op-
    erating system.
    --
    Johann | email: invalid -> com | http://www.myrkraverk.com/blog/
    I'm not from the Internet, I just work there. | via Easynews.com https://bsky.app/profile/myrkraverk.bsky.social | for ( ;; ) _:;
    Federated at https://fed.brid.gy/bsky/myrkraverk.bsky.social
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 30 12:12:11 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/2026 11:54 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/31/2026 12:53 AM, olcott wrote:
    On 10/30/2026 11:50 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/31/2026 12:14 AM, olcott wrote:
    On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/30/2026 11:11 PM, olcott wrote:
    On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string >>>>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the >>>>>>>> -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION. >>>>>>>> At this point we only need to see what is semantically entailed >>>>>>>> by these corrections.



    What exactly executes the new and corrected errors of computation? >>>>>>>
    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right?-a Wrong?-a How can you >>>>>>> -- not -- execute code with a Turing-machine?-a What else is there? >>>>>>
    Because Post canonical systems are Turing equivalent anything
    that cannot be derived by applying finite string transformations
    to finite strings is outside of the scope of computation.


    Ok, so show me your finite string machine!-a Don't be shy.-a I don't >>>>> mind
    raw electronics.

    Now go!

    https://github.com/plolcott/x86utm/blob/master/README.md


    That's just words on a screen.-a I was expecting a physical machine.-a Are >>> you lazy or something?-a Is there something wrong with a physical string >>> transformation machine?

    Surely you can build a small one with 74xx logic chips?

    x86utm is a minimal operating system that I wrote
    that implements HHH/DD as fully operational code.


    But it's not a physical machine of your design.-a It's merely an x86 op- erating system.

    A virtual machine is equivalent to a physical machine.
    VirtualBox, DOSBox and 86Box https://86box.net/
    are concrete examples.

    x86UTM enables one C function to run another
    C function a DebugStep mode.
    --
    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 30 11:20:56 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/2026 9:50 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/31/2026 12:14 AM, olcott wrote:
    On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/30/2026 11:11 PM, olcott wrote:
    On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string >>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the
    -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis.

    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
    At this point we only need to see what is semantically entailed
    by these corrections.



    What exactly executes the new and corrected errors of computation?

    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right?-a Wrong?-a How can you
    -- not -- execute code with a Turing-machine?-a What else is there?

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


    Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind >>> raw electronics.

    Now go!

    https://github.com/plolcott/x86utm/blob/master/README.md


    That's just words on a screen.-a I was expecting a physical machine.-a Are you lazy or something?-a Is there something wrong with a physical string transformation machine?

    Surely you can build a small one with 74xx logic chips?

    Before he does that, have him make one that can render, say, an L-system:

    https://en.wikipedia.org/wiki/L-system
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng on Fri Oct 30 11:21:42 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/2026 10:12 AM, olcott wrote:
    On 10/30/2026 11:54 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/31/2026 12:53 AM, olcott wrote:
    On 10/30/2026 11:50 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/31/2026 12:14 AM, olcott wrote:
    On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/30/2026 11:11 PM, olcott wrote:
    On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
    On 10/24/2026 2:10 AM, olcott wrote:
    These terms are replaced:
    (a) "Turing machine description" is replaced with
    -a-a-a-a [Finite string source code for a Turing Machine]

    The term: "description" is too vague the finite string
    source code actually specifies an exact sequence of steps.

    The term: "machine description" enables indirect
    reference to behavior other than the behavior specified
    by the input finite string of source code.

    (b) "Decider" and replace it with sequence of inference
    -a-a-a-a-a steps that are applied to an input static finite string >>>>>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the >>>>>>>>> -a-a-a-a-a decision criteria.

    -a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
    -a-a-a-a-a and the finite string inputs are the entire basis. >>>>>>>>>
    This tightens the term "decider" to the actual requirements
    that are never expressly stated. We can see things much
    more clearly with these additional details.

    WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION. >>>>>>>>> At this point we only need to see what is semantically entailed >>>>>>>>> by these corrections.



    What exactly executes the new and corrected errors of computation? >>>>>>>>
    It wouldn't be an Antikythera mechanism, would it?

    It would have to be a Turing-machine, right?-a Wrong?-a How can you >>>>>>>> -- not -- execute code with a Turing-machine?-a What else is there? >>>>>>>
    Because Post canonical systems are Turing equivalent anything
    that cannot be derived by applying finite string transformations >>>>>>> to finite strings is outside of the scope of computation.


    Ok, so show me your finite string machine!-a Don't be shy.-a I don't >>>>>> mind
    raw electronics.

    Now go!

    https://github.com/plolcott/x86utm/blob/master/README.md


    That's just words on a screen.-a I was expecting a physical machine. >>>> Are
    you lazy or something?-a Is there something wrong with a physical string >>>> transformation machine?

    Surely you can build a small one with 74xx logic chips?

    x86utm is a minimal operating system that I wrote
    that implements HHH/DD as fully operational code.


    But it's not a physical machine of your design.-a It's merely an x86 op-
    erating system.

    A virtual machine is equivalent to a physical machine.

    REALLY? That is a bit trusting on the VM size, right?


    VirtualBox, DOSBox and 86Box https://86box.net/
    are concrete examples.

    x86UTM enables one C function to run another
    C function a DebugStep mode.


    --- Synchronet 3.22a-Linux NewsLink 1.2