• How to make a halt decider?

    From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 6 20:08:54 2026
    From Newsgroup: comp.ai.philosophy

    Suppose there is a decider H that takes a finite
    string of source code S. H applies inference steps
    to S according to the operational semantics of the
    language of S.

    What exactly would that entail?
    --
    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,comp.ai.philosophy on Sat Nov 7 09:24:59 2026
    From Newsgroup: comp.ai.philosophy

    On 11/6/2026 8:08 PM, olcott wrote:
    Suppose there is a decider H that takes a finite
    string of source code S. H applies inference steps
    to S according to the operational semantics of the
    language of S.

    What exactly would that entail?


    What I mean by halt decider is more technically called
    a partial halt decider that correctly determines the
    halt status of some inputs.

    Software engineering calls this exact same thing a
    termination analyzer. Here is an example of one of these.

    AProVE: Non-Termination Witnesses for C Programsria https://link.springer.com/chapter/10.1007/978-3-030-99527-0_21

    How can a generic halt decider examine the behavior
    that a static finite string of source-code specifies?
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 15:56:30 2026
    From Newsgroup: comp.ai.philosophy

    Le 07/11/2026 |a 16:25, olcott a |-crit :
    On 11/6/2026 8:08 PM, olcott wrote:
    Suppose there is a decider H that takes a finite
    string of source code S. H applies inference steps
    to S according to the operational semantics of the
    language of S.

    What exactly would that entail?


    What I mean by halt decider is more technically called
    a partial halt decider that correctly determines the
    halt status of some inputs.

    Software engineering calls this exact same thing a
    termination analyzer. Here is an example of one of these.

    AProVE: Non-Termination Witnesses for C Programsria https://link.springer.com/chapter/10.1007/978-3-030-99527-0_21

    How can a generic halt decider examine the behavior
    that a static finite string of source-code specifies?

    Peter,

    WELL, FUCKING FINALLY.

    After twenty-two years of claiming to have refuted the Halting Theorem,
    you now write:

    "What I mean by halt decider is more technically
    called a partial halt decider that correctly
    determines the halt status of some inputs."

    GOOD.

    Then you have NOT refuted the Halting Theorem.

    Partial termination analyzers are perfectly legitimate. Nobody has ever disputed their existence.

    The Halting Theorem does not prohibit proving termination or
    non-termination for SOME programs.

    And the AProVE paper you cite is particularly instructive.

    AProVE uses symbolic execution and mathematical analysis to establish termination or non-termination. When it proves non-termination, it can
    produce a witness identifying a non-terminating execution path in the
    original program.

    THAT is what a justified non-termination result looks like.

    Now compare that with HHH.

    Your detector observes a finite pattern of calls and concludes that
    execution cannot terminate.

    WHERE IS YOUR PROOF THAT THIS PATTERN GUARANTEES NON-TERMINATION?

    WHERE IS YOUR CORRESPONDING NON-TERMINATION WITNESS?

    And please don't tell us that the input is a finite string. We already
    know that.

    As for your question:

    "How can a generic halt decider examine the behavior
    that a static finite string of source-code specifies?"

    By interpreting or analyzing the program according to its semantics.

    Through concrete execution, symbolic execution, abstract interpretation, invariants, ranking functions, transition systems, or other sound methods.

    NONE of these requires enumerating the entire execution trace.

    But every claimed result must be justified.

    And here is the decisive distinction:

    A partial analyzer may legitimately answer UNKNOWN.

    It may legitimately fail to terminate on some inputs.

    It may NOT legitimately answer DOES NOT HALT
    when the program actually halts.

    Calling such an input "outside the domain" AFTER your analyzer has
    returned the wrong answer does not make the answer correct.

    So let's establish your new position clearly.

    If HHH is merely a partial termination analyzer, then its existence is entirely compatible with the Halting Theorem.

    If you claim HHH correctly recognizes some non-terminating programs, prove
    its soundness on that class.

    If you claim it refutes the Halting Theorem, you need something MUCH
    stronger.

    You cannot have it both ways.

    And you certainly cannot use the existence of legitimate tools like AProVE
    as evidence that your own detector is correct.

    WELCOME TO THE ACTUAL SUBJECT OF TERMINATION ANALYSIS.

    Now prove that HHH belongs among the sound analyzers.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Tristan Wibberley@tristan.wibberley+netnews2@alumni.manchester.ac.uk to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 16:02:20 2026
    From Newsgroup: comp.ai.philosophy

    On 07/11/2026 02:08, olcott wrote:
    Suppose there is a decider H that takes a finite
    string of source code S. H applies inference steps
    to S according to the operational semantics of the
    language of S.

    What exactly would that entail?


    Since inference steps are applied rather than merely deterministic
    deduction steps, H is a person, at minimum H is an expression of a
    computer algebra language.

    H is not a program in the pre-war theoretical sense and it has an
    operator choice feature like a modern imperative or computer algebra system.

    It would entail using an entropy source to generate random numbers or
    the human brain (and perhaps the human brain does that).
    --
    Tristan Wibberley

    The message body is Copyright (C) 2026 Tristan Wibberley except
    citations and quotations noted. All Rights Reserved except that you may,
    of course, cite it academically giving credit to me, distribute it
    verbatim as part of a usenet system or its archives, and use it to
    promote my greatness and general superiority without misrepresentation
    of my opinions other than my opinion of my greatness and general
    superiority which you _may_ misrepresent. You definitely MAY NOT train
    any production AI system with it but you may train experimental AI that
    will only be used for evaluation of the AI methods it implements.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 10:24:01 2026
    From Newsgroup: comp.ai.philosophy

    On 11/7/2026 9:56 AM, Python wrote:
    Le 07/11/2026 |a 16:25, olcott a |-crit :
    On 11/6/2026 8:08 PM, olcott wrote:
    Suppose there is a decider H that takes a finite
    string of source code S. H applies inference steps
    to S according to the operational semantics of the
    language of S.

    What exactly would that entail?


    What I mean by halt decider is more technically called
    a partial halt decider that correctly determines the
    halt status of some inputs.

    Software engineering calls this exact same thing a
    termination analyzer. Here is an example of one of these.

    AProVE: Non-Termination Witnesses for C Programsria
    https://link.springer.com/chapter/10.1007/978-3-030-99527-0_21

    How can a generic halt decider examine the behavior
    that a static finite string of source-code specifies?

    Peter,

    WELL, FUCKING FINALLY.

    After twenty-two years of claiming to have refuted the Halting Theorem,
    you now write:

    -a-a "What I mean by halt decider is more technically
    -a-a-a called a partial halt decider that correctly
    -a-a-a determines the halt status of some inputs."

    GOOD.

    Then you have NOT refuted the Halting Theorem.


    That does not follow.

    Partial termination analyzers are perfectly legitimate. Nobody has ever disputed their existence.

    The Halting Theorem does not prohibit proving termination or non- termination for SOME programs.

    And the AProVE paper you cite is particularly instructive.

    AProVE uses symbolic execution and mathematical analysis to establish termination or non-termination. When it proves non-termination, it can produce a witness identifying a non-terminating execution path in the original program.

    THAT is what a justified non-termination result looks like.

    Now compare that with HHH.

    Your detector observes a finite pattern of calls and concludes that execution cannot terminate.

    WHERE IS YOUR PROOF THAT THIS PATTERN GUARANTEES NON-TERMINATION?


    I am not going to go around and around proving that
    same points that have been accepted as true. Only
    people playing head games would try and get away with
    that.

    *is shown to be equivalent to this*
    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    Halting is defined as reaching a final state
    you already agreed that is not possible for
    DD simulated by HHH.

    WHERE IS YOUR CORRESPONDING NON-TERMINATION WITNESS?

    And please don't tell us that the input is a finite string. We already
    know that.


    Too many people stupidly assume that it is a description
    of a machine. It is not a description of a machine. It
    is a finite string of source-code within a model of
    computation.

    As for your question:

    -a-a "How can a generic halt decider examine the behavior
    -a-a-a that a static finite string of source-code specifies?"

    By interpreting or analyzing the program according to its semantics.

    Through concrete execution, symbolic execution, abstract interpretation, invariants, ranking functions, transition systems, or other sound methods.

    NONE of these requires enumerating the entire execution trace.


    The end-result must be behavior equivalent to DD simulated by HHH
    try to prove otherwise or accept this.

    But every claimed result must be justified.


    Same idea as proof theoretic semantics.

    And here is the decisive distinction:

    -a-a A partial analyzer may legitimately answer UNKNOWN.

    -a-a It may legitimately fail to terminate on some inputs.

    -a-a It may NOT legitimately answer DOES NOT HALT
    -a-a when the program actually halts.


    I should have added how does termination analyzer HHH
    determine the behavior of some inputs such that it
    correctly determines the halt status specified by these
    static finite string inputs of source-code?

    Calling such an input "outside the domain" AFTER your analyzer has
    returned the wrong answer does not make the answer correct.

    So let's establish your new position clearly.

    If HHH is merely a partial termination analyzer, then its existence is entirely compatible with the Halting Theorem.


    I only made that qualification so that when I asked for
    the underlying detailed inference process I will actually
    get the details and not just "it can't be done"

    If you claim HHH correctly recognizes some non-terminating programs,
    prove its soundness on that class.

    If you claim it refutes the Halting Theorem, you need something MUCH stronger.

    You cannot have it both ways.

    And you certainly cannot use the existence of legitimate tools like
    AProVE as evidence that your own detector is correct.

    WELCOME TO THE ACTUAL SUBJECT OF TERMINATION ANALYSIS.

    Now prove that HHH belongs among the sound analyzers.

    I can only do this through Socratic questioning because
    people have made up their minds and closed them.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 16:36:29 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    HERE WE FUCKING GO AGAIN.

    You write:

    "I am not going to go around and around proving
    that same points that have been accepted as true."

    NOBODY IS ASKING YOU TO PROVE THE AGREED PROPOSITION AGAIN.

    We are asking you to prove what YOU CLAIM FOLLOWS FROM IT.

    And once again, you quote me:

    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.

    STOP USING MY WORDS AS SUPPORT FOR YOUR CONCLUSION.

    I have explicitly rejected that inference, repeatedly, publicly, and in unmistakable language.

    You KNOW that.

    You even admitted:

    "We have only established that HHH would be
    correct IF HHH did determine that."

    Exactly.

    You have not established that HHH DOES correctly determine it.

    And now you write:

    "The end-result must be behavior equivalent
    to DD simulated by HHH
    try to prove otherwise or accept this."

    NO.

    YOU are asserting that requirement.

    YOU must justify it.

    A sound termination analyzer must correctly establish the termination
    behavior specified by the program's semantics.

    It does NOT have to reproduce the particular execution trace of your HHH.

    A mathematical proof can establish a property of an execution without performing that execution.

    This is elementary.

    Then you admit:

    "I only made that qualification so that when
    I asked for the underlying detailed inference
    process I will actually get the details
    and not just 'it can't be done'."

    So your retreat to a "partial halt decider" was not actually a retreat
    from your claim to have refuted the Halting Theorem.

    It was a tactical change of terminology.

    Fine.

    Then stop equivocating between two completely different claims:

    1. HHH correctly determines halting for SOME inputs.

    2. HHH refutes the Halting Theorem.

    The first is entirely ordinary, provided you establish soundness.

    The second requires a genuine contradiction of the theorem's hypotheses
    and conclusion.

    And finally:

    "I can only do this through Socratic questioning
    because people have made up their minds and
    closed them."

    BULLSHIT.

    You are claiming to possess a MATHEMATICAL PROOF.

    A proof is a sequence of justified inferences.

    It can be written down.

    It can be checked.

    It does not require twenty-two years of leading questions, repeated quotations, manufactured consensus, or accusations that everyone else is
    too stupid or dishonest to understand.

    If your reasoning is valid, PRESENT IT.

    State your premises.

    State your inference rules.

    State your conclusion.

    Show precisely why your detector's finite observation establishes non-termination.

    And, crucially, distinguish the behavior of the simulated program from the behavior of the simulator that aborts it.

    THAT is the technical issue.

    Not whether I understand the word "semantic".

    Not whether your input is a finite string.

    Not whether Sipser agreed with a conditional statement.

    Not whether five people accepted a limited proposition.

    And certainly not whether your critics are sufficiently receptive to your "Socratic questioning".

    YOU CLAIM TO HAVE A PROOF.

    THEN FUCKING PRODUCE IT.

    And leave my name out of the conclusions I have explicitly rejected.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 10:56:57 2026
    From Newsgroup: comp.ai.philosophy

    On 11/7/2026 10:36 AM, Python wrote:
    Peter,

    HERE WE FUCKING GO AGAIN.

    You write:

    -a-a "I am not going to go around and around proving
    -a-a-a that same points that have been accepted as true."

    NOBODY IS ASKING YOU TO PROVE THE AGREED PROPOSITION AGAIN.

    We are asking you to prove what YOU CLAIM FOLLOWS FROM IT.

    And once again, you quote me:

    -a-a WHILE THE SIMULATION CONTINUES,
    -a-a DD DOES NOT REACH ITS RETURN.

    STOP USING MY WORDS AS SUPPORT FOR YOUR CONCLUSION.

    I have explicitly rejected that inference, repeatedly, publicly, and in unmistakable language.

    You KNOW that.

    You even admitted:

    -a-a "We have only established that HHH would be
    -a-a-a correct IF HHH did determine that."

    Exactly.

    You have not established that HHH DOES correctly determine it.

    And now you write:

    -a-a "The end-result must be behavior equivalent
    -a-a-a to DD simulated by HHH
    -a-a-a try to prove otherwise or accept this."

    NO.

    YOU are asserting that requirement.

    YOU must justify it.

    A sound termination analyzer must correctly establish the termination behavior specified by the program's semantics.


    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    The above is self-evidently true.
    I will not play head games with you on this.
    If you do not accept that HHH does correctly
    determine the above then I am done talking to you.

    It took me five years to get agreement on the
    above paragraph because everyone on this forum
    thought that lying about a self-evident truth
    was funny.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 17:10:31 2026
    From Newsgroup: comp.ai.philosophy

    Le 07/11/2026 |a 17:56, olcott a |-crit :
    On 11/7/2026 10:36 AM, Python wrote:
    Peter,

    HERE WE FUCKING GO AGAIN.

    You write:

    -a-a "I am not going to go around and around proving
    -a-a-a that same points that have been accepted as true."

    NOBODY IS ASKING YOU TO PROVE THE AGREED PROPOSITION AGAIN.

    We are asking you to prove what YOU CLAIM FOLLOWS FROM IT.

    And once again, you quote me:

    -a-a WHILE THE SIMULATION CONTINUES,
    -a-a DD DOES NOT REACH ITS RETURN.

    STOP USING MY WORDS AS SUPPORT FOR YOUR CONCLUSION.

    I have explicitly rejected that inference, repeatedly, publicly, and in
    unmistakable language.

    You KNOW that.

    You even admitted:

    -a-a "We have only established that HHH would be
    -a-a-a correct IF HHH did determine that."

    Exactly.

    You have not established that HHH DOES correctly determine it.

    And now you write:

    -a-a "The end-result must be behavior equivalent
    -a-a-a to DD simulated by HHH
    -a-a-a try to prove otherwise or accept this."

    NO.

    YOU are asserting that requirement.

    YOU must justify it.

    A sound termination analyzer must correctly establish the termination
    behavior specified by the program's semantics.


    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    The above is self-evidently true.
    I will not play head games with you on this.
    If you do not accept that HHH does correctly
    determine the above then I am done talking to you.

    It took me five years to get agreement on the
    above paragraph because everyone on this forum
    thought that lying about a self-evident truth
    was funny.

    Peter,

    You write:

    "There does not exist any implementation of C
    function HHH that simulates C function DD
    according to the operational semantics of C
    such that the simulated C function DD reaches
    its own simulated return statement in any N
    finite number of steps."

    And then:

    "The above is self-evidently true."

    NO, PETER.

    You have just made a universally quantified mathematical claim.

    You do not get to declare it "self-evident" and then accuse anyone who
    asks for a proof of lying.

    More importantly, you are AGAIN conflating two different propositions.

    I agreed that:

    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.

    That does not establish that your HHH correctly determines the halting behavior of DD.

    And your new statement does not establish it either.

    Let's consider the actual diagonal argument.

    Suppose HHH is a TOTAL and CORRECT halt decider.

    Then DD behaves as follows:

    If HHH(DD) says HALTS, DD loops.

    If HHH(DD) says DOES NOT HALT, DD returns.

    Therefore HHH cannot give a correct halting answer for DD.

    If HHH fails to return, it is not total.

    THAT IS THE CONTRADICTION.

    It establishes the impossibility of a total correct halt decider.

    It does NOT establish the correctness of your implementation.

    Now consider your actual simulator.

    There is an OUTER invocation of HHH.

    It simulates DD, which invokes a NESTED HHH.

    That nested invocation is part of the simulated computation.

    If the outer HHH aborts its simulation and returns DOES NOT HALT, this
    does NOT mean that the nested HHH returned DOES NOT HALT to DD.

    Those are DIFFERENT invocations.

    The simulated DD may simply have been abandoned before reaching any return statement.

    And THAT is exactly why your conclusion does not follow.

    You have to establish that the behavior observed by the outer HHH
    justifies its verdict about DD.

    You cannot establish that by pointing out that DD did not return BEFORE
    YOU ABORTED ITS SIMULATION.

    And you cannot establish it by repeatedly quoting my agreement to a
    different proposition.

    You say:

    "If you do not accept that HHH does correctly
    determine the above then I am done talking
    to you."

    That is not an argument.

    That is an ultimatum.

    You have spent years claiming to have refuted a mathematical theorem.

    The burden of proof is yours.

    If you want to stop talking rather than demonstrate the correctness of
    your inference, that is your choice.

    But stop pretending that my agreement to a limited statement constitutes acceptance of your purported proof.

    IT DOES NOT.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 11:18:08 2026
    From Newsgroup: comp.ai.philosophy

    On 11/7/2026 11:10 AM, Python wrote:
    Le 07/11/2026 |a 17:56, olcott a |-crit :
    On 11/7/2026 10:36 AM, Python wrote:
    Peter,

    HERE WE FUCKING GO AGAIN.

    You write:

    -a-a-a "I am not going to go around and around proving
    -a-a-a-a that same points that have been accepted as true."

    NOBODY IS ASKING YOU TO PROVE THE AGREED PROPOSITION AGAIN.

    We are asking you to prove what YOU CLAIM FOLLOWS FROM IT.

    And once again, you quote me:

    -a-a-a WHILE THE SIMULATION CONTINUES,
    -a-a-a DD DOES NOT REACH ITS RETURN.

    STOP USING MY WORDS AS SUPPORT FOR YOUR CONCLUSION.

    I have explicitly rejected that inference, repeatedly, publicly, and
    in unmistakable language.

    You KNOW that.

    You even admitted:

    -a-a-a "We have only established that HHH would be
    -a-a-a-a correct IF HHH did determine that."

    Exactly.

    You have not established that HHH DOES correctly determine it.

    And now you write:

    -a-a-a "The end-result must be behavior equivalent
    -a-a-a-a to DD simulated by HHH
    -a-a-a-a try to prove otherwise or accept this."

    NO.

    YOU are asserting that requirement.

    YOU must justify it.

    A sound termination analyzer must correctly establish the termination
    behavior specified by the program's semantics.


    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    The above is self-evidently true.
    I will not play head games with you on this.
    If you do not accept that HHH does correctly
    determine the above then I am done talking to you.

    It took me five years to get agreement on the
    above paragraph because everyone on this forum
    thought that lying about a self-evident truth
    was funny.

    Peter,

    You write:

    -a-a "There does not exist any implementation of C
    -a-a-a function HHH that simulates C function DD
    -a-a-a according to the operational semantics of C
    -a-a-a such that the simulated C function DD reaches
    -a-a-a its own simulated return statement in any N
    -a-a-a finite number of steps."

    And then:

    -a-a "The above is self-evidently true."

    NO, PETER.

    You have just made a universally quantified mathematical claim.

    You do not get to declare it "self-evident" and then accuse anyone who
    asks for a proof of lying.


    Good bye.

    More importantly, you are AGAIN conflating two different propositions.

    I agreed that:

    -a-a WHILE THE SIMULATION CONTINUES,
    -a-a DD DOES NOT REACH ITS RETURN.

    That does not establish that your HHH correctly determines the halting behavior of DD.

    And your new statement does not establish it either.

    Let's consider the actual diagonal argument.

    Suppose HHH is a TOTAL and CORRECT halt decider.

    Then DD behaves as follows:

    -a-a If HHH(DD) says HALTS, DD loops.

    -a-a If HHH(DD) says DOES NOT HALT, DD returns.

    Therefore HHH cannot give a correct halting answer for DD.

    If HHH fails to return, it is not total.

    THAT IS THE CONTRADICTION.

    It establishes the impossibility of a total correct halt decider.

    It does NOT establish the correctness of your implementation.

    Now consider your actual simulator.

    There is an OUTER invocation of HHH.

    It simulates DD, which invokes a NESTED HHH.

    That nested invocation is part of the simulated computation.

    If the outer HHH aborts its simulation and returns DOES NOT HALT, this
    does NOT mean that the nested HHH returned DOES NOT HALT to DD.

    Those are DIFFERENT invocations.

    The simulated DD may simply have been abandoned before reaching any
    return statement.

    And THAT is exactly why your conclusion does not follow.

    You have to establish that the behavior observed by the outer HHH
    justifies its verdict about DD.

    You cannot establish that by pointing out that DD did not return BEFORE
    YOU ABORTED ITS SIMULATION.

    And you cannot establish it by repeatedly quoting my agreement to a different proposition.

    You say:

    -a-a "If you do not accept that HHH does correctly
    -a-a-a determine the above then I am done talking
    -a-a-a to you."

    That is not an argument.

    That is an ultimatum.

    You have spent years claiming to have refuted a mathematical theorem.

    The burden of proof is yours.

    If you want to stop talking rather than demonstrate the correctness of
    your inference, that is your choice.

    But stop pretending that my agreement to a limited statement constitutes acceptance of your purported proof.

    IT DOES NOT.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 17:29:45 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Good bye."

    Fine.

    For the record, you have NOT demonstrated that your HHH correctly
    determines the halting status of DD.

    You have repeatedly quoted a proposition I agreed to, while refusing to justify the additional conclusion you draw from it.

    Those are TWO DIFFERENT THINGS.

    You have also failed to explain why aborting an outer simulation
    establishes the non-termination of the simulated program, rather than
    merely terminating the simulation itself.

    Declaring your conclusion "self-evident" is not a proof.

    Accusing people who request a proof of lying is not a proof.

    And walking away when asked to justify your inference is certainly not a proof.

    If you ever decide to provide an actual mathematical argument, rather than another quotation of my words, I will be happy to examine it.

    Until then, your claimed refutation of the Halting Theorem remains unsubstantiated.

    Goodbye.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 11:40:31 2026
    From Newsgroup: comp.ai.philosophy

    On 11/7/2026 11:29 AM, Python wrote:
    Peter,

    -a-a "Good bye."

    Fine.

    For the record, you have NOT demonstrated that your HHH correctly
    determines the halting status of DD.


    *is shown to be equivalent to this*
    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    Is a self-evident truth that people on this forum
    denied for five years because they thought denying
    a self-evident truth is funny.

    You have repeatedly quoted a proposition I agreed to, while refusing to justify the additional conclusion you draw from it.

    Those are TWO DIFFERENT THINGS.

    You have also failed to explain why aborting an outer simulation
    establishes the non-termination of the simulated program, rather than
    merely terminating the simulation itself.

    Declaring your conclusion "self-evident" is not a proof.

    Accusing people who request a proof of lying is not a proof.

    And walking away when asked to justify your inference is certainly not a proof.

    If you ever decide to provide an actual mathematical argument, rather
    than another quotation of my words, I will be happy to examine it.

    Until then, your claimed refutation of the Halting Theorem remains unsubstantiated.

    Goodbye.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 17:47:21 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    YOU SAID GOODBYE.

    And yet here you are again, repeating the SAME FUCKING QUOTATION.

    "WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN."

    YES, PETER. I SAID THAT.

    AND I STAND BY THOSE EXACT WORDS.

    What I do NOT accept is your claim that this establishes the correctness
    of HHH's non-halting verdict.

    HOW MANY FUCKING TIMES DO I HAVE TO EXPLAIN THE DIFFERENCE?

    You write:

    "*is shown to be equivalent to this*"

    SHOWN WHERE?

    BY WHAT ARGUMENT?

    BY WHICH INFERENCE RULE?

    You have not demonstrated an equivalence. You have merely ANNOUNCED one.

    And now you call it "self-evident".

    A statement about what happens WHILE a simulation continues is not, by
    itself, a proof that a program can NEVER terminate.

    In particular, your outer HHH can abort its simulation without the nested
    HHH ever returning a result to the simulated DD.

    THOSE ARE DIFFERENT EVENTS.

    That distinction has been explained to you repeatedly.

    You have NEVER addressed it.

    Instead, you recycle my quotation, accuse your critics of lying, and
    declare victory.

    Let me make something ABSOLUTELY CLEAR:

    **MY AGREEMENT TO ONE PROPOSITION IS NOT MY AGREEMENT TO YOUR
    CONCLUSIONS.**

    You do not get to manufacture my endorsement by repeatedly quoting half
    the argument.

    And this:

    "people on this forum denied for five years
    because they thought denying a self-evident
    truth is funny"

    is another baseless accusation.

    People have challenged your reasoning because you have FAILED TO JUSTIFY
    IT.

    Not because they enjoy lying.

    Not because they are playing games.

    Not because they are incapable of understanding your supposedly profound insights.

    BECAUSE YOU HAVE NOT PROVIDED THE FUCKING PROOF.

    Twenty-two years of repetition do not turn an unsupported inference into a theorem.

    Five years of arguments do not make your conclusion self-evident.

    And quoting me for the hundredth time does not establish anything beyond
    the words I actually wrote.

    You claim that HHH correctly determines non-termination.

    PROVE IT.

    You claim that your two propositions are equivalent.

    PROVE IT.

    You claim to have refuted the Halting Theorem.

    PROVE IT.

    Or admit that all you have is an assertion you cannot justify.

    And one last thing:

    STOP ACCUSING PEOPLE OF LYING SIMPLY BECAUSE THEY REFUSE TO ACCEPT YOUR UNPROVEN CLAIMS.

    That is not mathematics.

    That is intellectual dishonesty.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 12:09:26 2026
    From Newsgroup: comp.ai.philosophy

    On 11/7/2026 11:47 AM, Python wrote:
    Peter,

    YOU SAID GOODBYE.

    And yet here you are again, repeating the SAME FUCKING QUOTATION.

    -a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a DD DOES NOT REACH ITS RETURN."

    YES, PETER. I SAID THAT.

    AND I STAND BY THOSE EXACT WORDS.

    What I do NOT accept is your claim that this establishes the correctness
    of HHH's non-halting verdict.


    That part is OK to disagree with.
    The part that is not OK to disagree with is
    that HHH does not correctly determine the above.

    I already explained how HHH does this previously.
    That you still disagree that HHH does determine
    this will not be tolerated.

    HOW MANY FUCKING TIMES DO I HAVE TO EXPLAIN THE DIFFERENCE?

    You write:

    -a-a "*is shown to be equivalent to this*"

    SHOWN WHERE?

    BY WHAT ARGUMENT?

    BY WHICH INFERENCE RULE?

    You have not demonstrated an equivalence. You have merely ANNOUNCED one.

    And now you call it "self-evident".

    A statement about what happens WHILE a simulation continues is not, by itself, a proof that a program can NEVER terminate.

    In particular, your outer HHH can abort its simulation without the
    nested HHH ever returning a result to the simulated DD.

    THOSE ARE DIFFERENT EVENTS.

    That distinction has been explained to you repeatedly.

    You have NEVER addressed it.

    Instead, you recycle my quotation, accuse your critics of lying, and
    declare victory.

    Let me make something ABSOLUTELY CLEAR:

    **MY AGREEMENT TO ONE PROPOSITION IS NOT MY AGREEMENT TO YOUR
    CONCLUSIONS.**

    You do not get to manufacture my endorsement by repeatedly quoting half
    the argument.

    And this:

    -a-a "people on this forum denied for five years
    -a-a-a because they thought denying a self-evident
    -a-a-a truth is funny"

    is another baseless accusation.

    People have challenged your reasoning because you have FAILED TO JUSTIFY
    IT.

    Not because they enjoy lying.

    Not because they are playing games.

    Not because they are incapable of understanding your supposedly profound insights.

    BECAUSE YOU HAVE NOT PROVIDED THE FUCKING PROOF.

    Twenty-two years of repetition do not turn an unsupported inference into
    a theorem.

    Five years of arguments do not make your conclusion self-evident.

    And quoting me for the hundredth time does not establish anything beyond
    the words I actually wrote.

    You claim that HHH correctly determines non-termination.

    PROVE IT.

    You claim that your two propositions are equivalent.

    PROVE IT.

    You claim to have refuted the Halting Theorem.

    PROVE IT.

    Or admit that all you have is an assertion you cannot justify.

    And one last thing:

    STOP ACCUSING PEOPLE OF LYING SIMPLY BECAUSE THEY REFUSE TO ACCEPT YOUR UNPROVEN CLAIMS.

    That is not mathematics.

    That is intellectual dishonesty.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 18:28:15 2026
    From Newsgroup: comp.ai.philosophy

    Le 07/11/2026 |a 19:09, olcott a |-crit :
    On 11/7/2026 11:47 AM, Python wrote:
    Peter,

    YOU SAID GOODBYE.

    And yet here you are again, repeating the SAME FUCKING QUOTATION.

    -a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a DD DOES NOT REACH ITS RETURN."

    YES, PETER. I SAID THAT.

    AND I STAND BY THOSE EXACT WORDS.

    What I do NOT accept is your claim that this establishes the correctness
    of HHH's non-halting verdict.


    That part is OK to disagree with.
    The part that is not OK to disagree with is
    that HHH does not correctly determine the above.

    I already explained how HHH does this previously.
    That you still disagree that HHH does determine
    this will not be tolerated.

    Peter,

    "That you still disagree that HHH does determine
    this will not be tolerated."

    WILL NOT BE TOLERATED?

    Who the fuck do you think you are?

    This is a technical discussion, not a courtroom in which you get to
    declare objections inadmissible.

    And we have something considerably more substantial than your repeated assertions.

    WE HAVE A CONCRETE COUNTEREXAMPLE TO YOUR DETECTOR.

    Remember this program?

    ```c
    typedef void (*fn)(unsigned);

    void F(unsigned);
    void G(unsigned);
    void Done(unsigned);

    void Done(unsigned n) { (void)n; }

    void G(unsigned n)
    {
    fn next[2] = { F, Done };
    fn p = next[n];
    p(n + 1);
    }

    void F(unsigned n) { G(n); }

    void P(void) { F(0); }
    ```

    Its execution is straightforward:

    P()
    F(0)
    G(0)
    F(1)
    G(1)
    Done(2)

    Then everything returns.

    THE PROGRAM HALTS.

    Yet the same direct call from F to G occurs twice.

    Your detector looks for repeated call instructions with matching addresses
    and targets, without checking the complete computational state.

    That is NOT sufficient to establish infinite recursion.

    And when you tested this example, you reported that HHH returned 0.

    When I explained that the program actually terminates, you replied:

    "Then it is simply outside the domain of HHH."

    HOW CONVENIENT.

    Your detector reports non-halting.

    The program halts.

    And suddenly the program is outside your domain.

    That is not a proof of correctness.

    That is moving the goalposts.

    If HHH is a partial termination analyzer, DEFINE ITS DOMAIN IN ADVANCE and demonstrate that every definitive answer within that domain is correct.

    If HHH claims to decide DD correctly, explain why its actual detection criterion is sound for DD.

    And stop confusing these statements:

    DD has not returned during the observed simulation.

    DD can never return.

    THEY ARE NOT THE SAME CLAIM.

    Your detector has already demonstrated why this distinction matters.

    So instead of telling me what disagreement you will or will not
    "tolerate", answer one concrete question:

    WHAT PROPERTY OF THE COMPLETE COMPUTATIONAL STATE DOES YOUR DETECTOR
    ESTABLISH THAT MAKES FUTURE TERMINATION IMPOSSIBLE?

    Not another quotation.

    Not another declaration of self-evidence.

    Not another accusation of lying.

    AN ACTUAL TECHNICAL ANSWER.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 12:35:35 2026
    From Newsgroup: comp.ai.philosophy

    On 11/7/2026 12:28 PM, Python wrote:
    Le 07/11/2026 |a 19:09, olcott a |-crit :
    On 11/7/2026 11:47 AM, Python wrote:
    Peter,

    YOU SAID GOODBYE.

    And yet here you are again, repeating the SAME FUCKING QUOTATION.

    -a-a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a-a DD DOES NOT REACH ITS RETURN."

    YES, PETER. I SAID THAT.

    AND I STAND BY THOSE EXACT WORDS.

    What I do NOT accept is your claim that this establishes the
    correctness of HHH's non-halting verdict.


    That part is OK to disagree with.
    The part that is not OK to disagree with is
    that HHH does not correctly determine the above.

    I already explained how HHH does this previously.
    That you still disagree that HHH does determine
    this will not be tolerated.

    Peter,

    -a-a "That you still disagree that HHH does determine
    -a-a-a this will not be tolerated."

    WILL NOT BE TOLERATED?

    Who the fuck do you think you are?

    This is a technical discussion, not a courtroom in which you get to
    declare objections inadmissible.



    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    People on this forum refused to acknowledge
    the above self-evident truth for five years
    because they were playing head games and thought
    this was funny.

    Anyone that is not a damned liar and has sufficient
    technical competence can see exactly how HHH(DD)
    determines this. Everyone else can fuck off.


    And we have something considerably more substantial than your repeated assertions.

    WE HAVE A CONCRETE COUNTEREXAMPLE TO YOUR DETECTOR.

    Remember this program?

    ```c
    typedef void (*fn)(unsigned);

    void F(unsigned);
    void G(unsigned);
    void Done(unsigned);

    void Done(unsigned n) { (void)n; }

    void G(unsigned n)
    {
    -a-a fn next[2] = { F, Done };
    -a-a fn p = next[n];
    -a-a p(n + 1);
    }

    void F(unsigned n) { G(n); }

    void P(void) { F(0); }
    ```

    Its execution is straightforward:

    -a-a P()
    -a-a-a-a F(0)
    -a-a-a-a-a-a G(0)
    -a-a-a-a-a-a-a-a F(1)
    -a-a-a-a-a-a-a-a-a-a G(1)
    -a-a-a-a-a-a-a-a-a-a-a-a Done(2)

    Then everything returns.

    THE PROGRAM HALTS.

    Yet the same direct call from F to G occurs twice.

    Your detector looks for repeated call instructions with matching
    addresses and targets, without checking the complete computational state.

    That is NOT sufficient to establish infinite recursion.

    And when you tested this example, you reported that HHH returned 0.

    When I explained that the program actually terminates, you replied:

    -a-a "Then it is simply outside the domain of HHH."

    HOW CONVENIENT.

    Your detector reports non-halting.

    The program halts.

    And suddenly the program is outside your domain.

    That is not a proof of correctness.

    That is moving the goalposts.

    If HHH is a partial termination analyzer, DEFINE ITS DOMAIN IN ADVANCE
    and demonstrate that every definitive answer within that domain is correct.

    If HHH claims to decide DD correctly, explain why its actual detection criterion is sound for DD.

    And stop confusing these statements:

    -a-a DD has not returned during the observed simulation.

    -a-a DD can never return.

    THEY ARE NOT THE SAME CLAIM.

    Your detector has already demonstrated why this distinction matters.

    So instead of telling me what disagreement you will or will not
    "tolerate", answer one concrete question:

    WHAT PROPERTY OF THE COMPLETE COMPUTATIONAL STATE DOES YOUR DETECTOR ESTABLISH THAT MAKES FUTURE TERMINATION IMPOSSIBLE?

    Not another quotation.

    Not another declaration of self-evidence.

    Not another accusation of lying.

    AN ACTUAL TECHNICAL ANSWER.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 7 18:41:41 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    YOU HAVE JUST IGNORED THE ENTIRE TECHNICAL COUNTEREXAMPLE.

    Not one word about the C program.

    Not one word about its demonstrable termination.

    Not one word about your own report that HHH returned 0.

    Not one word about your subsequent excuse:

    "Then it is simply outside the domain of HHH."

    Instead, you quote me AGAIN:

    "WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN."

    YES. WE FUCKING KNOW.

    That quotation does not make the counterexample disappear.

    YOUR DETECTOR IDENTIFIES A REPEATED CALL PATTERN IN A PROGRAM THAT
    TERMINATES.

    YOU REPORTED A NON-HALTING VERDICT FOR THAT PROGRAM.

    THEN YOU RETROACTIVELY EXCLUDED IT FROM YOUR DOMAIN.

    Those are concrete technical facts that your latest reply does absolutely nothing to address.

    And this:

    "Anyone that is not a damned liar and has sufficient
    technical competence can see exactly how HHH(DD)
    determines this. Everyone else can fuck off."

    is not a technical response.

    It is an attempt to replace mathematical justification with abuse.

    YOU are the person claiming to have refuted the Halting Theorem.

    YOU are the person whose detector has been challenged with a terminating program.

    YOU are the person who must establish the correctness of its decisions.

    Calling everyone else a liar does not discharge that burden.

    So I will ask ONE question, and ONE question only:

    WHY DID YOUR HHH RETURN 0 FOR A PROGRAM
    THAT PROVABLY TERMINATES?

    Either explain the result, identify an error in the test, or specify a previously established restriction that excludes the program.

    But stop hiding behind my quotation.

    I AM NOT YOUR FUCKING ALIBI.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 08:32:10 2026
    From Newsgroup: comp.ai.philosophy

    On 11/7/2026 12:41 PM, Python wrote:
    Peter,

    YOU HAVE JUST IGNORED THE ENTIRE TECHNICAL COUNTEREXAMPLE.


    It was a dishonest dodge away from HHH(DD)==0

    Not one word about the C program.

    Not one word about its demonstrable termination.

    Not one word about your own report that HHH returned 0.

    Not one word about your subsequent excuse:

    -a-a "Then it is simply outside the domain of HHH."

    Instead, you quote me AGAIN:

    -a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a DD DOES NOT REACH ITS RETURN."

    YES. WE FUCKING KNOW.

    That quotation does not make the counterexample disappear.

    YOUR DETECTOR IDENTIFIES A REPEATED CALL PATTERN IN A PROGRAM THAT TERMINATES.

    YOU REPORTED A NON-HALTING VERDICT FOR THAT PROGRAM.

    THEN YOU RETROACTIVELY EXCLUDED IT FROM YOUR DOMAIN.

    Those are concrete technical facts that your latest reply does
    absolutely nothing to address.

    And this:

    -a-a "Anyone that is not a damned liar and has sufficient
    -a-a-a technical competence can see exactly how HHH(DD)
    -a-a-a determines this. Everyone else can fuck off."

    is not a technical response.

    It is an attempt to replace mathematical justification with abuse.

    YOU are the person claiming to have refuted the Halting Theorem.

    YOU are the person whose detector has been challenged with a terminating program.

    YOU are the person who must establish the correctness of its decisions.

    Calling everyone else a liar does not discharge that burden.

    So I will ask ONE question, and ONE question only:

    -a-a WHY DID YOUR HHH RETURN 0 FOR A PROGRAM
    -a-a THAT PROVABLY TERMINATES?

    Either explain the result, identify an error in the test, or specify a previously established restriction that excludes the program.

    But stop hiding behind my quotation.

    I AM NOT YOUR FUCKING ALIBI.
    --
    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,comp.ai.philosophy on Sun Nov 8 08:48:25 2026
    From Newsgroup: comp.ai.philosophy

    On 11/7/2026 12:28 PM, Python wrote:
    Le 07/11/2026 |a 19:09, olcott a |-crit :
    On 11/7/2026 11:47 AM, Python wrote:
    Peter,

    YOU SAID GOODBYE.

    And yet here you are again, repeating the SAME FUCKING QUOTATION.

    -a-a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a-a DD DOES NOT REACH ITS RETURN."

    YES, PETER. I SAID THAT.

    AND I STAND BY THOSE EXACT WORDS.

    What I do NOT accept is your claim that this establishes the
    correctness of HHH's non-halting verdict.


    That part is OK to disagree with.
    The part that is not OK to disagree with is
    that HHH does not correctly determine the above.

    I already explained how HHH does this previously.
    That you still disagree that HHH does determine
    this will not be tolerated.

    Peter,

    -a-a "That you still disagree that HHH does determine
    -a-a-a this will not be tolerated."

    WILL NOT BE TOLERATED?

    Who the fuck do you think you are?


    A person that will not tolerate abuse.
    It took five years on comp.theory to get people
    to acknowledge the sequence of steps of DD simulated
    by HHH. Once we know that

    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    They only refused to acknowledge that so that they could
    play sadistic head games. What person that is interested
    in the theory of computation does not know the first thing
    about programming? What MD has no idea what disease is?

    It does not take a genius to see that HHH can see that
    DD calls HHH(DD) in recursive simulation. It only takes
    a comp.theory reviewer that is not dishonest.

    01 int DD()
    02 {
    03 int Halt_Status = HHH(DD);
    04 if (Halt_Status)
    05 HERE: goto HERE;
    06 return Halt_Status;
    07 }

    Pretending to not see that that HHH can see that the
    same function has been called from the same address
    with no conditional statements from the beginning of
    DD to this call is just playing head games and a form
    of abuse that I will not tolerate.

    The difficult theory of computation steps are showing
    exactly how HHH(DD)==0 is correct within this definition
    of computation:

    Computation defined
    Paraphrase of Emil Post definition of computation
    All computations are equivalent applying 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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    That is the part that comp.theory people should be
    interested in.

    This is a technical discussion, not a courtroom in which you get to
    declare objections inadmissible.

    And we have something considerably more substantial than your repeated assertions.

    WE HAVE A CONCRETE COUNTEREXAMPLE TO YOUR DETECTOR.

    Remember this program?

    ```c
    typedef void (*fn)(unsigned);

    void F(unsigned);
    void G(unsigned);
    void Done(unsigned);

    void Done(unsigned n) { (void)n; }

    void G(unsigned n)
    {
    -a-a fn next[2] = { F, Done };
    -a-a fn p = next[n];
    -a-a p(n + 1);
    }

    void F(unsigned n) { G(n); }

    void P(void) { F(0); }
    ```

    Its execution is straightforward:

    -a-a P()
    -a-a-a-a F(0)
    -a-a-a-a-a-a G(0)
    -a-a-a-a-a-a-a-a F(1)
    -a-a-a-a-a-a-a-a-a-a G(1)
    -a-a-a-a-a-a-a-a-a-a-a-a Done(2)

    Then everything returns.

    THE PROGRAM HALTS.

    Yet the same direct call from F to G occurs twice.

    Your detector looks for repeated call instructions with matching
    addresses and targets, without checking the complete computational state.

    That is NOT sufficient to establish infinite recursion.

    And when you tested this example, you reported that HHH returned 0.

    When I explained that the program actually terminates, you replied:

    -a-a "Then it is simply outside the domain of HHH."

    HOW CONVENIENT.

    Your detector reports non-halting.

    The program halts.

    And suddenly the program is outside your domain.

    That is not a proof of correctness.

    That is moving the goalposts.

    If HHH is a partial termination analyzer, DEFINE ITS DOMAIN IN ADVANCE
    and demonstrate that every definitive answer within that domain is correct.

    If HHH claims to decide DD correctly, explain why its actual detection criterion is sound for DD.

    And stop confusing these statements:

    -a-a DD has not returned during the observed simulation.

    -a-a DD can never return.

    THEY ARE NOT THE SAME CLAIM.

    Your detector has already demonstrated why this distinction matters.

    So instead of telling me what disagreement you will or will not
    "tolerate", answer one concrete question:

    WHAT PROPERTY OF THE COMPLETE COMPUTATIONAL STATE DOES YOUR DETECTOR ESTABLISH THAT MAKES FUTURE TERMINATION IMPOSSIBLE?

    Not another quotation.

    Not another declaration of self-evidence.

    Not another accusation of lying.

    AN ACTUAL TECHNICAL ANSWER.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 18:46:51 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "A person that will not tolerate abuse."

    OH, FOR FUCK'S SAKE.

    You have spent years calling people liars, dishonest, incompetent, and accusing them of playing "sadistic head games" whenever they challenge
    your arguments.

    And now YOU are the victim of abuse?

    GIVE ME A FUCKING BREAK.

    But let's get to the mathematics, because your latest message contains a rather spectacular admission.

    You write:

    "The difficult theory of computation steps are
    showing exactly how HHH(DD)==0 is correct"

    EXACTLY, PETER.

    THAT IS THE FUCKING QUESTION I HAVE BEEN ASKING YOU.

    FOR YEARS.

    You have finally identified the very thing you have consistently failed to demonstrate.

    Nobody disputes that HHH can observe a call to HHH(DD) during its
    simulation of DD.

    Nobody disputes that a simulator can recognize repeated call instructions.

    Nobody disputes that DD has not reached its return statement during the observed execution prefix.

    WHAT WE DISPUTE IS YOUR CLAIM THAT THESE OBSERVATIONS ESTABLISH A CORRECT NON-HALTING VERDICT.

    And your own implementation gives us a very good reason to dispute it.

    REMEMBER THE COUNTEREXAMPLE YOU KEEP IGNORING?

    P()
    F(0)
    G(0)
    F(1)
    G(1)
    Done(2)

    THE PROGRAM TERMINATES.

    The same call instruction from F to G occurs twice.

    Your HHH reportedly returned 0.

    When I demonstrated that the program terminates, your response was:

    "Then it is simply outside the domain of HHH."

    YOU HAVE STILL NOT EXPLAINED THAT RESULT.

    NOT ONCE.

    Instead, you keep recycling the same quotation and accusing everyone else
    of dishonesty.

    Now you invoke Emil Post:

    "All computations are equivalent applying finite
    string transformation rules to finite string
    inputs to derive any and all outputs."

    AND?

    Post canonical systems are computationally universal.

    THEY ARE NOT MAGICAL HALTING ORACLES.

    The fact that computation can be expressed through effective
    transformations of finite strings does not imply that every semantic
    property of the resulting computation is decidable.

    A finite string can describe a computation that never terminates.

    A finite program can generate an unbounded execution.

    And the fact that your HHH can examine that finite description does not establish that its conclusions are correct.

    YOU ARE CONFUSING THE REPRESENTABILITY OF A COMPUTATION WITH THE
    DECIDABILITY OF ITS HALTING BEHAVIOR.

    AGAIN.

    Your latest message actually exposes the central failure of your argument.

    You have established that your simulator can observe a particular
    recursive call pattern.

    You have NOT established that its decision to return 0 is semantically correct.

    You yourself now acknowledge that proving the correctness of HHH(DD)==0 is
    the difficult part.

    SO WHERE IS THAT PROOF?

    Not the quotation from November 2.

    Not another story about five years of supposedly dishonest reviewers.

    Not another lecture about finite strings.

    Not another appeal to Post.

    And not another fucking tantrum about what you will or will not tolerate.

    THE PROOF.

    You claim to have refuted the Halting Theorem, yet you cannot even give a satisfactory technical explanation for the terminating counterexample your
    own detector mishandled.

    And while you are at it, stop dragging my agreement to a limited
    observation into your claims of mathematical victory.

    I HAVE NOT ENDORSED YOUR CONCLUSION.

    I HAVE NOT ACCEPTED YOUR PROOF.

    AND I AM NOT RESPONSIBLE FOR YOUR INABILITY TO PROVIDE ONE.

    If you cannot distinguish between observing recursive calls and proving non-termination, you have no business lecturing other people about their competence in computability theory.

    Now either address the counterexample and establish the soundness of your detector, or stop pretending that insulting your critics constitutes a refutation of Turing.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 13:36:37 2026
    From Newsgroup: comp.ai.philosophy

    On 11/8/2026 12:46 PM, Python wrote:
    Peter,

    -a-a "A person that will not tolerate abuse."

    OH, FOR FUCK'S SAKE.

    You have spent years calling people liars, dishonest, incompetent, and accusing them of playing "sadistic head games" whenever they challenge
    your arguments.

    And now YOU are the victim of abuse?

    GIVE ME A FUCKING BREAK.

    But let's get to the mathematics, because your latest message contains a rather spectacular admission.

    You write:

    -a-a "The difficult theory of computation steps are
    -a-a-a showing exactly how HHH(DD)==0 is correct"

    EXACTLY, PETER.

    THAT IS THE FUCKING QUESTION I HAVE BEEN ASKING YOU.

    FOR YEARS.


    Yet you and others never even acknowledged the
    C programming aspect of this until last Sunday.

    There does not exist any implementation of C
    function HHH that simulates C function DD
    according to the operational semantics of C
    such that the simulated C function DD reaches
    its own simulated return statement in any N
    finite number of steps.

    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    It took five years before someone on this group
    stopped stonewalling on the above point.

    You have finally identified the very thing you have consistently failed
    to demonstrate.


    ALL of the mandaory prerequisites must come first.

    Nobody disputes that HHH can observe a call to HHH(DD) during its
    simulation of DD.

    Nobody disputes that a simulator can recognize repeated call instructions.

    Nobody disputes that DD has not reached its return statement during the observed execution prefix.

    WHAT WE DISPUTE IS YOUR CLAIM THAT THESE OBSERVATIONS ESTABLISH A
    CORRECT NON-HALTING VERDICT.


    So if you acknowledge that HHH can see that:
    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    And not require me to prove this dead obvious
    ordinary C programming self-evident truth
    then we can finally get on to the meat of the
    matter. How is HHH(DD)==0 correct within this
    definition:

    Computation defined
    Paraphrase of Emil Post definition of computation
    All computations are equivalent applying 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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    We must go one tiny step at a time establishing mutual
    understanding at each tiny step.

    And your own implementation gives us a very good reason to dispute it.

    REMEMBER THE COUNTEREXAMPLE YOU KEEP IGNORING?

    -a-a P()
    -a-a-a-a F(0)
    -a-a-a-a-a-a G(0)
    -a-a-a-a-a-a-a-a F(1)
    -a-a-a-a-a-a-a-a-a-a G(1)
    -a-a-a-a-a-a-a-a-a-a-a-a Done(2)

    THE PROGRAM TERMINATES.


    A dishonest dodge away from the domain of HHH.
    I am only claiming that HHH(DD)==0 is correct.

    I did not and will not spent the infinite amount
    of time required to write a universal halt decider.

    <snip>
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 20:11:14 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "A dishonest dodge away from the domain of HHH.
    I am only claiming that HHH(DD)==0 is correct."

    OH, FOR FUCK'S SAKE.

    So NOW you are only claiming that HHH correctly decides ONE PARTICULAR PROGRAM?

    FINE.

    Then stop pretending that the existence of HHH constitutes a refutation of
    the Halting Theorem.

    The theorem does not prohibit an algorithm from correctly deciding the
    halting behavior of one particular program.

    Or ten programs.

    Or infinitely many programs belonging to some restricted class.

    THAT HAS NEVER BEEN IN DISPUTE.

    But there is still a problem with your particular claim.

    You say HHH correctly determines that DD does not halt.

    HOW?

    You repeatedly answer by pointing out that DD calls HHH(DD) during the simulation.

    YES, PETER.

    WE KNOW.

    You then point out that the same call instruction is encountered again.

    YES, PETER.

    WE KNOW THAT TOO.

    And you quote me for the hundredth fucking time:

    "WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN."

    YES.

    I AGREED TO THAT OBSERVATION.

    WHAT I HAVE NOT AGREED TO IS THAT YOUR DETECTOR'S OBSERVATION CONSTITUTES
    A SOUND PROOF OF NON-TERMINATION.

    And the reason is concrete.

    YOUR DETECTOR'S CALL-PATTERN CRITERION IS NOT GENERALLY SOUND.

    We demonstrated that with a terminating program.

    You reported HHH returning 0.

    Then you excluded the program from your domain.

    Now you call mentioning that counterexample a "dishonest dodge".

    NO.

    It is a direct challenge to the soundness of the inference rule your implementation uses.

    Of course, a detector that fails on another program might still give the correct answer for DD.

    BUT YOU HAVE TO PROVE THAT.

    You cannot simply assume that an unsound general criterion becomes sound whenever the input happens to be DD.

    You need a DD-SPECIFIC ARGUMENT.

    And that argument must distinguish:

    HHH observes DD invoking a nested HHH.

    from:

    HHH proves that DD cannot terminate.

    Those are not identical propositions.

    Your outer HHH can terminate its simulation without the nested HHH
    returning anything to DD.

    ABORTING THE SIMULATION IS NOT THE SAME AS COMPLETING THE SIMULATED COMPUTATION.

    Now about your latest appeal to Emil Post.

    You write:

    "Because Post canonical systems are Turing-equivalent,
    anything that cannot be derived by applying finite
    string transformations to finite string inputs is
    outside of the domain of Church-Turing computable
    functions."

    This does not rescue your argument.

    Turing equivalence establishes equivalence of computational power.

    It does not provide a procedure for deciding every semantic property of computations represented by finite strings.

    In particular, it does not establish the correctness of HHH(DD)==0.

    And this is particularly revealing:

    "I did not and will not spent the infinite amount
    of time required to write a universal halt decider."

    THE FUCKING HALTING THEOREM DOES NOT SAY THAT WRITING A UNIVERSAL HALT
    DECIDER WOULD TAKE INFINITE TIME.

    It says that no total computable function can correctly decide the halting problem for every program-input pair.

    That is an impossibility theorem, not an estimate of software development effort.

    After all these years, you should know the difference.

    Finally, you write:

    "We must go one tiny step at a time establishing
    mutual understanding at each tiny step."

    We have already established the observation you keep quoting.

    I HAVE ACKNOWLEDGED IT.

    REPEATEDLY.

    So stop demanding that I acknowledge it again.

    The next step is YOURS.

    Show the precise argument establishing that the particular behavior of DD, under the specified semantics and the actual implementation of HHH, makes HHH(DD)==0 a correct halting verdict.

    Not a repeated CALL.

    Not a finite execution prefix.

    Not a quotation from me.

    Not an appeal to Post.

    Not another accusation of dishonesty.

    A FUCKING PROOF.

    And if all you are claiming is a correct result for ONE program, stop presenting that as a refutation of a theorem about ALL programs.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 14:57:19 2026
    From Newsgroup: comp.ai.philosophy

    On 11/8/2026 2:11 PM, Python wrote:
    Peter,

    -a-a "A dishonest dodge away from the domain of HHH.
    -a-a-a I am only claiming that HHH(DD)==0 is correct."

    OH, FOR FUCK'S SAKE.

    So NOW you are only claiming that HHH correctly decides ONE PARTICULAR PROGRAM?

    FINE.

    Then stop pretending that the existence of HHH constitutes a refutation
    of the Halting Theorem.

    The theorem does not prohibit an algorithm from correctly deciding the halting behavior of one particular program.


    A specific isomorphism of an input that does the
    opposite of whatever value its decider returns.

    Once that isomorphism is handled nothing more is
    needed. Trying to pretend otherwise is stonewalling.

    Or ten programs.

    Or infinitely many programs belonging to some restricted class.

    THAT HAS NEVER BEEN IN DISPUTE.

    But there is still a problem with your particular claim.

    You say HHH correctly determines that DD does not halt.

    HOW?

    You repeatedly answer by pointing out that DD calls HHH(DD) during the simulation.

    YES, PETER.

    WE KNOW.

    You then point out that the same call instruction is encountered again.

    YES, PETER.

    WE KNOW THAT TOO.

    And you quote me for the hundredth fucking time:

    -a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    I AGREED TO THAT OBSERVATION.

    WHAT I HAVE NOT AGREED TO IS THAT YOUR DETECTOR'S OBSERVATION
    CONSTITUTES A SOUND PROOF OF NON-TERMINATION.

    And the reason is concrete.

    YOUR DETECTOR'S CALL-PATTERN CRITERION IS NOT GENERALLY SOUND.

    We demonstrated that with a terminating program.

    You reported HHH returning 0.

    Then you excluded the program from your domain.

    Now you call mentioning that counterexample a "dishonest dodge".

    NO.

    It is a direct challenge to the soundness of the inference rule your implementation uses.

    Of course, a detector that fails on another program might still give the correct answer for DD.

    BUT YOU HAVE TO PROVE THAT.

    You cannot simply assume that an unsound general criterion becomes sound whenever the input happens to be DD.

    You need a DD-SPECIFIC ARGUMENT.

    And that argument must distinguish:

    -a-a HHH observes DD invoking a nested HHH.

    from:

    -a-a HHH proves that DD cannot terminate.

    Those are not identical propositions.

    Your outer HHH can terminate its simulation without the nested HHH
    returning anything to DD.

    ABORTING THE SIMULATION IS NOT THE SAME AS COMPLETING THE SIMULATED COMPUTATION.

    Now about your latest appeal to Emil Post.

    You write:

    -a-a "Because Post canonical systems are Turing-equivalent,
    -a-a-a anything that cannot be derived by applying finite
    -a-a-a string transformations to finite string inputs is
    -a-a-a outside of the domain of Church-Turing computable
    -a-a-a functions."

    This does not rescue your argument.

    Turing equivalence establishes equivalence of computational power.


    Stonewalling on the ordinary C portion as everyone
    here has done for five years up until last week
    prevented me from getting to the next step after
    this mandatory prerequisite.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 21:15:55 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "A specific isomorphism of an input that does
    the opposite of whatever value its decider returns."

    ISOMORPHISM?

    DO YOU EVEN KNOW WHAT THAT WORD MEANS?

    An isomorphism is a bijection between mathematical structures that
    preserves the relevant structure.

    So tell us:

    WHAT ARE THE TWO STRUCTURES?

    WHAT IS THE BIJECTION?

    WHAT STRUCTURE DOES IT PRESERVE?

    You have specified NONE of these.

    What you are vaguely describing is the DIAGONAL CONSTRUCTION: a program designed to behave contrary to the prediction of a purported halt decider.

    That is not some mysterious "specific isomorphism".

    And the diagonal construction is precisely what proves that a total,
    correct, universal halt decider cannot exist.

    It does not prove that YOUR HHH has somehow defeated the theorem.

    Quite the fucking opposite.

    Now you write:

    "Once that isomorphism is handled nothing more
    is needed."

    HANDLED HOW?

    If your HHH returns 0 for DD, then you must establish that this is a
    correct prediction of DD's behavior under the specified semantics.

    You cannot establish correctness merely by interrupting the simulation
    before DD returns.

    You cannot establish it by observing a repeated CALL instruction.

    And you certainly cannot establish it by inventing an "isomorphism" you
    have not defined.

    Then there is your latest fairy tale:

    "Stonewalling on the ordinary C portion as everyone
    here has done for five years up until last week
    prevented me from getting to the next step..."

    BULLSHIT.

    NOTHING MATHEMATICALLY SIGNIFICANT HAPPENED LAST WEEK.

    I did not suddenly discover how C function calls work.

    I did not concede that your detector is correct.

    I did not accept your purported refutation.

    I merely agreed to an explicitly qualified statement:

    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.

    THAT IS ALL.

    You have been quoting it obsessively ever since, pretending that this elementary observation somehow unlocks twenty-two years of missing mathematics.

    IT DOES NOT.

    And nobody has prevented you from presenting your alleged next step.

    Nobody has confiscated your keyboard.

    Nobody has forbidden you to write down your proof.

    Nobody has imposed a five-year waiting period on mathematical reasoning.

    YOU HAVE BEEN FREE TO PRESENT YOUR ARGUMENT THE ENTIRE FUCKING TIME.

    Instead, you insist that everyone first accept an ever-expanding
    collection of supposedly "self-evident" prerequisites, while accusing
    anyone who questions your conclusions of lying and stonewalling.

    That is not how mathematics works.

    If your proof is valid, it stands on its stated assumptions and justified inferences.

    It does not depend on obtaining ceremonial declarations of agreement from Usenet participants.

    And here is the funniest part:

    You now say that your entire argument concerns ONE PARTICULAR DIAGONAL PROGRAM.

    Fine.

    Even a correct termination result for that particular program would not
    refute the Halting Theorem.

    To refute the theorem, you would have to invalidate its actual
    mathematical conclusion, not merely demonstrate that a restricted analyzer sometimes produces a correct answer.

    So enough with the undefined "isomorphisms".

    Enough with the fictional breakthrough last week.

    Enough with the five-year persecution narrative.

    And enough with using my words as a substitute for your missing proof.

    YOU SAY THERE IS A NEXT STEP.

    THEN FUCKING PRESENT IT.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 15:30:57 2026
    From Newsgroup: comp.ai.philosophy

    On 11/8/2026 3:15 PM, Python wrote:
    Peter,

    -a-a "A specific isomorphism of an input that does
    -a-a-a the opposite of whatever value its decider returns."

    ISOMORPHISM?

    DO YOU EVEN KNOW WHAT THAT WORD MEANS?

    An isomorphism is a bijection between mathematical structures that
    preserves the relevant structure.

    So tell us:

    WHAT ARE THE TWO STRUCTURES?


    What-ever input is encoded to do the opposite of what
    its decider reports <is> the HP counter-example input.

    I am only going to address one point per reply to
    keep attention focused on the most relevant.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 21:40:55 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "What-ever input is encoded to do the opposite
    of what its decider reports <is> the HP
    counter-example input."

    THAT IS NOT AN ISOMORPHISM.

    That is a vague description of DIAGONALIZATION.

    You used the mathematical term "isomorphism".

    I asked you to identify the two mathematical structures and the structure-preserving bijection between them.

    YOU HAVE ANSWERED NEITHER QUESTION.

    And your description misses the essential point of the Halting Theorem.

    The diagonal program is constructed RELATIVE TO a hypothetical total,
    correct halt decider H.

    Its contradictory behavior demonstrates that no such H can exist.

    It does NOT establish that your particular HHH has somehow solved the contradiction.

    Quite the fucking opposite.

    You write:

    "I am only going to address one point per reply"

    EXCELLENT.

    Then address THIS ONE POINT:

    WHAT EXACTLY IS THE ISOMORPHISM YOU CLAIM EXISTS?

    Define its domain, codomain, mapping, and preserved structure.

    Or admit that you used a mathematical term you cannot define in this
    context.

    One point. One question.

    NO MORE FUCKING EVASIONS.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 15:45:54 2026
    From Newsgroup: comp.ai.philosophy

    On 11/8/2026 3:40 PM, Python wrote:
    Peter,

    -a-a "What-ever input is encoded to do the opposite
    -a-a-a of what its decider reports <is> the HP
    -a-a-a counter-example input."

    THAT IS NOT AN ISOMORPHISM.


    Isomorphic (from Greek isos meaning "equal" and
    morph-o meaning "form" or "shape") generally means
    having identical or similar form, shape, or structure.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 21:54:18 2026
    From Newsgroup: comp.ai.philosophy

    Le 08/11/2026 |a 22:45, olcott a |-crit :
    On 11/8/2026 3:40 PM, Python wrote:
    Peter,

    -a-a "What-ever input is encoded to do the opposite
    -a-a-a of what its decider reports <is> the HP
    -a-a-a counter-example input."

    THAT IS NOT AN ISOMORPHISM.


    Isomorphic (from Greek isos meaning "equal" and
    morph-o meaning "form" or "shape") generally means
    having identical or similar form, shape, or structure.


    OH, FOR FUCK'S SAKE.

    I asked you to DEFINE THE MATHEMATICAL ISOMORPHISM YOU CLAIM EXISTS.

    And you respond with the GREEK ETYMOLOGY of the word?

    SERIOUSLY?

    We are discussing a mathematical theorem, not playing Scrabble.

    You claimed:

    "A specific isomorphism of an input..."

    An isomorphism in mathematics requires specified structures and a structure-preserving bijection.

    I asked you:

    WHAT ARE THE TWO STRUCTURES?

    WHAT IS THE MAPPING?

    WHAT STRUCTURE IS PRESERVED?

    And instead of answering, you explain that "isos" means equal and
    "morph-o" means shape.

    THANK YOU FOR THE FUCKING GREEK LESSON.

    Now back to mathematics.

    If you merely mean that diagonal programs have a similar structure, say "similar structure".

    If you mean an actual mathematical isomorphism, DEFINE IT.

    And if you cannot, stop dressing up a vague analogy in mathematical terminology.

    ONE POINT PER REPLY, REMEMBER?

    Then ANSWER THE POINT.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 16:07:19 2026
    From Newsgroup: comp.ai.philosophy

    On 11/8/2026 3:54 PM, Python wrote:
    Le 08/11/2026 |a 22:45, olcott a |-crit :
    On 11/8/2026 3:40 PM, Python wrote:
    Peter,

    -a-a-a "What-ever input is encoded to do the opposite
    -a-a-a-a of what its decider reports <is> the HP
    -a-a-a-a counter-example input."

    THAT IS NOT AN ISOMORPHISM.


    Isomorphic (from Greek isos meaning "equal" and
    morph-o meaning "form" or "shape") generally means
    having identical or similar form, shape, or structure.


    OH, FOR FUCK'S SAKE.

    I asked you to DEFINE THE MATHEMATICAL ISOMORPHISM YOU CLAIM EXISTS.

    I don't answer questions having false assumptions.
    I correct the false assumption.

    My system applies to the standard input that does the opposite
    of whatever value its decider returns. In the last two years
    I recovered from cancer twice and still cannot walk fast
    without needing oxygen from my very severe PJP pneumonia.

    I am not going to go around and around addressing an
    unlimited number of misconceptions.

    (1) My HHH/DD does accurately encode the decider/input
    pair of the HP.

    (2) On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    (3) HHH does correctly determine this.

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

    (4) (2) & (3) prove the Sipser approved criteria has been met
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 22:09:18 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    First, I am sorry to hear about your cancer and pneumonia. I sincerely
    hope your recovery continues.

    Now, FINALLY, you have numbered your argument.

    GOOD.

    That makes it possible to identify the precise logical error.

    You write:

    (2) WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.

    Agreed, with exactly that qualification.

    Then:

    (3) HHH does correctly determine this.

    For the sake of argument, GRANTED.

    HHH can recognize that DD has not reached its return during the observed simulation.

    Now look at the actual condition in your Sipser quotation:

    "H correctly determines that its simulated D
    would NEVER stop running UNLESS aborted"

    NEVER, PETER.

    NOT "has not stopped yet".

    NOT "has not reached its return during the observed simulation".

    NOT "has recursively called HHH".

    NEVER.

    Your point (4) claims:

    "(2) & (3) prove the Sipser approved
    criteria has been met."

    NO. THEY FUCKING DON'T.

    You have substituted a weaker proposition for the actual hypothesis of the conditional statement.

    Let me spell it out:

    A: DD has not returned during the
    simulation observed by HHH.

    B: HHH correctly recognizes A.

    C: DD would never terminate if its
    execution continued without abortion.

    Sipser's conditional requires HHH to establish C.

    Your premises establish, at most, A and B.

    WHERE IS THE PROOF OF C?

    That is the missing inference.

    And there is a second problem.

    The outer HHH aborting its simulation does not mean the nested HHH
    returned a value to DD.

    You must distinguish those invocations before drawing conclusions about
    DD's behavior.

    Your quotation from Sipser does not help you here.

    It is CONDITIONAL.

    It says that IF H correctly determines non-termination, THEN H may
    correctly report non-termination.

    Of course.

    NOBODY DISPUTES THAT.

    What you have to establish is that your HHH actually satisfies the IF.

    You cannot prove the antecedent by quoting the consequent.

    And you cannot turn an observation about a finite simulation into a proof about all future execution merely by declaring the two equivalent.

    So your argument currently has this form:

    (2) A.

    (3) HHH correctly recognizes A.

    (4) Therefore HHH correctly establishes C.

    INVALID.

    YOU HAVE NOT PROVIDED THE STEP FROM A TO C.

    This is not stonewalling.

    This is not a misconception.

    This is not a refusal to understand C programming.

    THIS IS THE EXACT LOGICAL GAP IN YOUR NUMBERED ARGUMENT.

    You wanted to proceed one step at a time.

    Excellent.

    Then prove this ONE step:

    WHY DOES THE FACT THAT DD HAS NOT RETURNED
    DURING THE SIMULATION ESTABLISH THAT DD
    WOULD NEVER TERMINATE IF EXECUTION CONTINUED?

    Until you answer that question, your point (4) is simply a non sequitur.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 16:20:27 2026
    From Newsgroup: comp.ai.philosophy

    On 11/8/2026 4:09 PM, Python wrote:
    Peter,

    First, I am sorry to hear about your cancer and pneumonia. I sincerely
    hope your recovery continues.

    Now, FINALLY, you have numbered your argument.

    GOOD.

    That makes it possible to identify the precise logical error.

    You write:

    -a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a DD DOES NOT REACH ITS RETURN.

    Agreed, with exactly that qualification.

    Then:

    -a-a (3) HHH does correctly determine this.

    For the sake of argument, GRANTED.

    HHH can recognize that DD has not reached its return during the observed simulation.

    Now look at the actual condition in your Sipser quotation:

    -a-a "H correctly determines that its simulated D
    -a-a-a would NEVER stop running UNLESS aborted"

    NEVER, PETER.

    (2) WHILE THE SIMULATION CONTINUES,
    (AKA has not been aborted)
    DD DOES NOT REACH ITS RETURN.

    You cannot even agree with your own words.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 22:31:04 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "WHILE THE SIMULATION CONTINUES,
    (AKA has not been aborted)
    DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.

    Now compare:

    WHILE the simulation continues,
    DD does not reach its return.

    with:

    WITHOUT abortion, DD would NEVER
    reach its return.

    THESE ARE NOT LOGICALLY EQUIVALENT.

    "Has not yet been aborted" does not mean "would run forever unless
    aborted".

    And observing that DD has not returned during the simulation does not, by itself, prove what would happen if the simulation continued indefinitely.

    Your Sipser quotation requires the SECOND proposition.

    My agreement concerns the FIRST.

    You cannot transform one into the other by inserting "AKA".

    That is not a proof. It is a substitution of an unproved conclusion.

    And accusing me of disagreeing with my own words does not repair the
    missing inference.

    YOU STILL HAVE TO PROVE THAT DD WOULD NEVER TERMINATE WITHOUT ABORTION.

    Not that it hasn't returned yet.

    That it NEVER WOULD.

    THAT IS THE FUCKING DIFFERENCE.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 8 16:55:00 2026
    From Newsgroup: comp.ai.philosophy

    On 11/8/2026 4:31 PM, Python wrote:
    Peter,

    -a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a (AKA has not been aborted)
    -a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.


    (AKA has not been aborted)
    (AKA has not been aborted)
    (AKA has not been aborted)

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

    Maybe you just have a hard time paying close attention?
    --
    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,comp.ai.philosophy on Sun Nov 8 20:42:00 2026
    From Newsgroup: comp.ai.philosophy

    On 11/8/2026 4:31 PM, Python wrote:
    Peter,

    -a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a (AKA has not been aborted)
    -a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.

    Now compare:

    -a-a WHILE the simulation continues,
    -a-a DD does not reach its return.

    with:
    WHILE the simulation (has not been aborted),
    DD does not reach its return.
    --
    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,comp.ai.philosophy on Mon Nov 9 10:50:14 2026
    From Newsgroup: comp.ai.philosophy

    On 07/11/2026 04:08, olcott wrote:
    Suppose there is a decider H that takes a finite
    string of source code S. H applies inference steps
    to S according to the operational semantics of the
    language of S.

    What exactly would that entail?

    At least that H knows the operational semantics of every language that
    has operational semantics. For example, it knows what the string
    "#&%#%#&&#" operational means according to my specification of the
    operational semantics of my language.
    --
    Mikko
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 09:07:11 2026
    From Newsgroup: comp.ai.philosophy

    Le 08/11/2026 |a 23:55, olcott a |-crit :
    On 11/8/2026 4:31 PM, Python wrote:
    Peter,

    -a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a (AKA has not been aborted)
    -a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.


    (AKA has not been aborted)
    (AKA has not been aborted)
    (AKA has not been aborted)

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

    Maybe you just have a hard time paying close attention?

    Peter,

    "(AKA has not been aborted)"
    "(AKA has not been aborted)"
    "(AKA has not been aborted)"

    Yes, Peter. I CAN READ.

    Now YOU try reading the sentence you keep quoting:

    "H correctly determines that its simulated D
    would NEVER stop running unless aborted"

    The crucial words are:

    CORRECTLY DETERMINES
    WOULD NEVER STOP RUNNING

    Not merely:

    UNLESS ABORTED

    You have to PROVE that DD would never terminate if the simulation were
    allowed to continue.

    Repeating "unless aborted" three times does not establish that.

    A simulation that has not yet terminated might terminate later.

    A simulation that has been aborted tells you nothing, BY ITSELF, about
    whether it would eventually have terminated.

    Your quotation from Sipser assumes that H has CORRECTLY DETERMINED non-termination.

    It does not explain how H achieves that determination.

    THAT IS PRECISELY WHAT YOU HAVE TO PROVE ABOUT HHH.

    So stop chanting "unless aborted" like a religious incantation.

    SHOW THE PROOF.

    What property of DD's execution establishes that it could NEVER reach its return?

    And why is HHH's detection of that property SOUND?

    Until you answer those questions, you are simply assuming the very
    conclusion you claim to have demonstrated.

    Maybe YOU should try paying attention to the words preceding "unless
    aborted".

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 07:53:07 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 3:07 AM, Python wrote:
    Le 08/11/2026 |a 23:55, olcott a |-crit :
    On 11/8/2026 4:31 PM, Python wrote:
    Peter,

    -a-a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a-a (AKA has not been aborted)
    -a-a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.


    -a (AKA has not been aborted)
    -a (AKA has not been aborted)
    -a (AKA has not been aborted)

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

    Maybe you just have a hard time paying close attention?

    Peter,

    -a-a "(AKA has not been aborted)"
    -a-a "(AKA has not been aborted)"
    -a-a "(AKA has not been aborted)"

    Yes, Peter. I CAN READ.

    Now YOU try reading the sentence you keep quoting:

    -a-a "H correctly determines that its simulated D
    -a-a-a would NEVER stop running unless aborted"

    The crucial words are:

    -a-a CORRECTLY DETERMINES
    -a-a WOULD NEVER STOP RUNNING

    Not merely:

    -a-a UNLESS ABORTED

    You have to PROVE that [the simulated] DD would never terminate if the simulation were
    allowed to continue.


    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    That's what those words mean.

    reaching its return means halting
    halting means stops running.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 14:15:18 2026
    From Newsgroup: comp.ai.philosophy

    Le 09/11/2026 |a 14:53, olcott a |-crit :
    On 11/9/2026 3:07 AM, Python wrote:
    Le 08/11/2026 |a 23:55, olcott a |-crit :
    On 11/8/2026 4:31 PM, Python wrote:
    Peter,

    -a-a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a-a (AKA has not been aborted)
    -a-a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.


    -a (AKA has not been aborted)
    -a (AKA has not been aborted)
    -a (AKA has not been aborted)

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

    Maybe you just have a hard time paying close attention?

    Peter,

    -a-a "(AKA has not been aborted)"
    -a-a "(AKA has not been aborted)"
    -a-a "(AKA has not been aborted)"

    Yes, Peter. I CAN READ.

    Now YOU try reading the sentence you keep quoting:

    -a-a "H correctly determines that its simulated D
    -a-a-a would NEVER stop running unless aborted"

    The crucial words are:

    -a-a CORRECTLY DETERMINES
    -a-a WOULD NEVER STOP RUNNING

    Not merely:

    -a-a UNLESS ABORTED

    You have to PROVE that [the simulated] DD would never terminate if the
    simulation were
    allowed to continue.


    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    That's what those words mean.

    reaching its return means halting
    halting means stops running.

    Peter,

    "reaching its return means halting
    halting means stops running."

    CONGRATULATIONS.

    You have successfully explained what "halting" means.

    Now try understanding what "WHILE" means.

    I wrote:

    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.

    That describes what happens DURING the simulation.

    It does NOT assert that the simulation would continue forever if it were
    not aborted.

    Consider a program that returns after 1,000,000 steps.

    Abort its simulation after 100 steps.

    Then:

    WHILE THE SIMULATION CONTINUED,
    THE PROGRAM DID NOT REACH ITS RETURN.

    TRUE.

    But:

    THE PROGRAM WOULD NEVER REACH ITS RETURN
    UNLESS THE SIMULATION WERE ABORTED.

    FALSE.

    Do you understand the difference?

    Of course, this example does not establish that DD halts. It demonstrates
    that the inference you keep making is INVALID.

    You need an additional argument, SPECIFIC TO DD, proving that it would
    never reach its return without abortion.

    And you need to demonstrate that HHH actually establishes that fact
    correctly.

    Neither follows from the sentence you keep quoting.

    You have spent days repeating my agreement with a statement about the simulation, pretending it constitutes agreement with your conclusion about non-termination.

    IT DOES NOT.

    And defining "halting" for the hundredth time won't make it so.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 08:32:49 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 8:15 AM, Python wrote:
    Le 09/11/2026 |a 14:53, olcott a |-crit :
    On 11/9/2026 3:07 AM, Python wrote:
    Le 08/11/2026 |a 23:55, olcott a |-crit :
    On 11/8/2026 4:31 PM, Python wrote:
    Peter,

    -a-a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a-a (AKA has not been aborted)
    -a-a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.


    -a (AKA has not been aborted)
    -a (AKA has not been aborted)
    -a (AKA has not been aborted)

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

    Maybe you just have a hard time paying close attention?

    Peter,

    -a-a-a "(AKA has not been aborted)"
    -a-a-a "(AKA has not been aborted)"
    -a-a-a "(AKA has not been aborted)"

    Yes, Peter. I CAN READ.

    Now YOU try reading the sentence you keep quoting:

    -a-a-a "H correctly determines that its simulated D
    -a-a-a-a would NEVER stop running unless aborted"

    The crucial words are:

    -a-a-a CORRECTLY DETERMINES
    -a-a-a WOULD NEVER STOP RUNNING

    Not merely:

    -a-a-a UNLESS ABORTED

    You have to PROVE that [the simulated] DD would never terminate if
    the simulation were allowed to continue.


    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    That's what those words mean.

    reaching its return means halting
    halting means stops running.

    Peter,

    -a-a "reaching its return means halting
    -a-a-a halting means stops running."

    CONGRATULATIONS.

    You have successfully explained what "halting" means.

    Now try understanding what "WHILE" means.

    I wrote:

    -a-a WHILE THE SIMULATION CONTINUES,
    -a-a DD DOES NOT REACH ITS RETURN.

    That describes what happens DURING the simulation.


    never stop running unless [simulation is] aborted
    means
    while being simulated

    I don't see how you don't get this AND are honest.
    --
    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,comp.ai.philosophy on Mon Nov 9 08:47:13 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 8:15 AM, Python wrote:
    Le 09/11/2026 |a 14:53, olcott a |-crit :
    On 11/9/2026 3:07 AM, Python wrote:
    Le 08/11/2026 |a 23:55, olcott a |-crit :
    On 11/8/2026 4:31 PM, Python wrote:
    Peter,

    -a-a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a-a (AKA has not been aborted)
    -a-a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.


    -a (AKA has not been aborted)
    -a (AKA has not been aborted)
    -a (AKA has not been aborted)

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

    Maybe you just have a hard time paying close attention?

    Peter,

    -a-a-a "(AKA has not been aborted)"
    -a-a-a "(AKA has not been aborted)"
    -a-a-a "(AKA has not been aborted)"

    Yes, Peter. I CAN READ.

    Now YOU try reading the sentence you keep quoting:

    -a-a-a "H correctly determines that its simulated D
    -a-a-a-a would NEVER stop running unless aborted"

    The crucial words are:

    -a-a-a CORRECTLY DETERMINES
    -a-a-a WOULD NEVER STOP RUNNING

    Not merely:

    -a-a-a UNLESS ABORTED

    You have to PROVE that [the simulated] DD would never terminate if
    the simulation were allowed to continue.


    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    That's what those words mean.

    reaching its return means halting
    halting means stops running.

    Peter,

    -a-a "reaching its return means halting
    -a-a-a halting means stops running."

    CONGRATULATIONS.

    You have successfully explained what "halting" means.

    Now try understanding what "WHILE" means.

    I wrote:

    -a-a WHILE THE SIMULATION CONTINUES,
    -a-a DD DOES NOT REACH ITS RETURN.

    That describes what happens DURING the simulation.



    unless [simulation is] aborted
    means
    while being simulated

    I don't see how you don't get this AND are honest.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 15:18:58 2026
    From Newsgroup: comp.ai.philosophy

    Le 09/11/2026 |a 15:47, olcott a |-crit :
    On 11/9/2026 8:15 AM, Python wrote:
    Le 09/11/2026 |a 14:53, olcott a |-crit :
    On 11/9/2026 3:07 AM, Python wrote:
    Le 08/11/2026 |a 23:55, olcott a |-crit :
    On 11/8/2026 4:31 PM, Python wrote:
    Peter,

    -a-a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a-a (AKA has not been aborted)
    -a-a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.


    -a (AKA has not been aborted)
    -a (AKA has not been aborted)
    -a (AKA has not been aborted)

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

    Maybe you just have a hard time paying close attention?

    Peter,

    -a-a-a "(AKA has not been aborted)"
    -a-a-a "(AKA has not been aborted)"
    -a-a-a "(AKA has not been aborted)"

    Yes, Peter. I CAN READ.

    Now YOU try reading the sentence you keep quoting:

    -a-a-a "H correctly determines that its simulated D
    -a-a-a-a would NEVER stop running unless aborted"

    The crucial words are:

    -a-a-a CORRECTLY DETERMINES
    -a-a-a WOULD NEVER STOP RUNNING

    Not merely:

    -a-a-a UNLESS ABORTED

    You have to PROVE that [the simulated] DD would never terminate if
    the simulation were allowed to continue.


    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    That's what those words mean.

    reaching its return means halting
    halting means stops running.

    Peter,

    -a-a "reaching its return means halting
    -a-a-a halting means stops running."

    CONGRATULATIONS.

    You have successfully explained what "halting" means.

    Now try understanding what "WHILE" means.

    I wrote:

    -a-a WHILE THE SIMULATION CONTINUES,
    -a-a DD DOES NOT REACH ITS RETURN.

    That describes what happens DURING the simulation.



    unless [simulation is] aborted
    means
    while being simulated

    I don't see how you don't get this AND are honest.

    Peter,

    "unless [simulation is] aborted
    means
    while being simulated"

    FINE.

    LET'S GRANT THAT.

    Now explain how:

    DD DOES NOT RETURN WHILE BEING SIMULATED

    logically implies:

    DD WOULD NEVER RETURN IF THE SIMULATION
    WERE ALLOWED TO CONTINUE WITHOUT ABORTION.

    THAT IS THE QUESTION.

    It has been the question for DAYS.

    And you keep answering a DIFFERENT question.

    A program can fail to return during a finite simulation and nevertheless return later.

    So the fact that DD has not returned before HHH aborts its simulation does not, BY ITSELF, establish non-termination.

    Perhaps you have some additional argument specific to DD.

    THEN PRESENT THE FUCKING ARGUMENT.

    But repeating "unless aborted", redefining "while", and accusing me of dishonesty will not establish it.

    You claim HHH CORRECTLY DETERMINES that DD would never terminate.

    PROVE THAT CLAIM.

    And please, for once, answer the actual question instead of explaining
    English words that nobody is disputing.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 09:24:40 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 9:18 AM, Python wrote:
    Le 09/11/2026 |a 15:47, olcott a |-crit :
    On 11/9/2026 8:15 AM, Python wrote:
    Le 09/11/2026 |a 14:53, olcott a |-crit :
    On 11/9/2026 3:07 AM, Python wrote:
    Le 08/11/2026 |a 23:55, olcott a |-crit :
    On 11/8/2026 4:31 PM, Python wrote:
    Peter,

    -a-a-a "WHILE THE SIMULATION CONTINUES,
    -a-a-a-a (AKA has not been aborted)
    -a-a-a-a DD DOES NOT REACH ITS RETURN."

    YES.

    FOR THE HUNDREDTH FUCKING TIME, YES.

    I agree with those exact words.


    -a (AKA has not been aborted)
    -a (AKA has not been aborted)
    -a (AKA has not been aborted)

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

    Maybe you just have a hard time paying close attention?

    Peter,

    -a-a-a "(AKA has not been aborted)"
    -a-a-a "(AKA has not been aborted)"
    -a-a-a "(AKA has not been aborted)"

    Yes, Peter. I CAN READ.

    Now YOU try reading the sentence you keep quoting:

    -a-a-a "H correctly determines that its simulated D
    -a-a-a-a would NEVER stop running unless aborted"

    The crucial words are:

    -a-a-a CORRECTLY DETERMINES
    -a-a-a WOULD NEVER STOP RUNNING

    Not merely:

    -a-a-a UNLESS ABORTED

    You have to PROVE that [the simulated] DD would never terminate if
    the simulation were allowed to continue.


    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    That's what those words mean.

    reaching its return means halting
    halting means stops running.

    Peter,

    -a-a-a "reaching its return means halting
    -a-a-a-a halting means stops running."

    CONGRATULATIONS.

    You have successfully explained what "halting" means.

    Now try understanding what "WHILE" means.

    I wrote:

    -a-a-a WHILE THE SIMULATION CONTINUES,
    -a-a-a DD DOES NOT REACH ITS RETURN.

    That describes what happens DURING the simulation.



    unless [simulation is] aborted
    means
    while being simulated

    I don't see how you don't get this AND are honest.

    Peter,

    -a-a "unless [simulation is] aborted
    -a-a-a means
    -a-a-a while being simulated"

    FINE.

    LET'S GRANT THAT.


    OK good. The sign of an honest dialogue.

    Now explain how:

    -a-a DD DOES NOT RETURN WHILE BEING SIMULATED

    logically implies:

    -a-a DD WOULD NEVER RETURN IF THE SIMULATION
    -a-a WERE ALLOWED TO CONTINUE WITHOUT ABORTION.

    THAT IS THE QUESTION.


    Those are not the words that are needed.
    These are the words that are needed:

    simulated D would never stop running unless [simulation is] aborted
    becomes
    simulated D would never stop running while being simulated
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 15:40:18 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "simulated D would never stop running
    unless [simulation is] aborted"

    becomes:

    "simulated D would never stop running
    while being simulated"

    FINE.

    And now?

    You have merely REPHRASED THE SAME CLAIM.

    You have not PROVED IT.

    The words "would never stop running" are precisely the part that requires justification.

    Your argument amounts to:

    HHH correctly determines that DD
    would never stop running.

    WHY?

    Because DD would never stop running
    while being simulated.

    HOW DO YOU KNOW?

    Because HHH correctly determines it.

    THAT IS CIRCULAR REASONING.

    I have agreed that DD does not reach its return DURING THE SIMULATION
    ACTUALLY PERFORMED.

    I have NOT agreed that DD could never reach its return if the simulation continued.

    And I certainly have not agreed that HHH has correctly established that stronger proposition.

    Changing "unless aborted" into "while being simulated" does not bridge
    that logical gap.

    You are rearranging words instead of proving anything.

    FOR FUCK'S SAKE, PETER.

    STOP PARAPHRASING YOUR CONCLUSION.

    PROVE IT.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 09:43:34 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a "simulated D would never stop running
    -a-a-a unless [simulation is] aborted"

    becomes:

    -a-a "simulated D would never stop running
    -a-a-a while being simulated"

    FINE.

    And now?

    You have merely REPHRASED THE SAME CLAIM.

    You have not PROVED IT.

    The words "would never stop running" are precisely the part that
    requires justification.


    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    You already conceded that.

    Does not reach its return means never halts
    would never stop running means never halts
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 15:56:00 2026
    From Newsgroup: comp.ai.philosophy

    Le 09/11/2026 |a 16:43, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a "simulated D would never stop running
    -a-a-a unless [simulation is] aborted"

    becomes:

    -a-a "simulated D would never stop running
    -a-a-a while being simulated"

    FINE.

    And now?

    You have merely REPHRASED THE SAME CLAIM.

    You have not PROVED IT.

    The words "would never stop running" are precisely the part that
    requires justification.


    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    You already conceded that.

    Does not reach its return means never halts
    would never stop running means never halts

    Peter,

    "You already conceded that."

    NO.

    I conceded EXACTLY this:

    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.

    You now write:

    "Does not reach its return means never halts"

    WHERE THE FUCK DID "NEVER" COME FROM?

    A program that has not reached its return YET may reach it later.

    A simulation that has been aborted cannot tell us, merely from its lack of
    a return before abortion, whether the simulated program would eventually
    halt.

    You keep silently deleting the qualification from my statement, then pretending I agreed with your stronger conclusion.

    I DID NOT.

    And there is an even more fundamental distinction you keep ignoring:

    When the OUTER HHH aborts its simulation of DD, that does not mean the
    INNER HHH has returned a value to DD.

    Those are DIFFERENT invocations.

    So, once again:

    What EXACT property of DD's execution proves that it would never reach its return if the simulation continued without abortion?

    Not a quotation from me.

    Not a definition of "halt".

    Not another paraphrase of "unless aborted".

    A PROOF.

    Until you provide one, your claim that HHH correctly determines DD's non-termination remains unsupported.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 12:18:40 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a "simulated D would never stop running
    -a-a-a unless [simulation is] aborted"

    becomes:

    -a-a "simulated D would never stop running
    -a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    is translated into
    "simulated D would never stop running while being simulated"
    [would never stop running]
    is translated into
    never halts

    [simulated D would never stop running unless aborted]
    becomes
    "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    > WHILE THE SIMULATION CONTINUES,
    > DD DOES NOT REACH ITS RETURN.
    >
    [REACH ITS RETURN]
    is translated into
    HALT

    On 11/2/2026 8:50 AM, Python wrote:
    > WHILE THE SIMULATION CONTINUES,
    > DD DOES NOT REACH ITS RETURN.
    >
    is translated into
    WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT
    --
    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 Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 12:26:57 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 7:56 AM, Python wrote:
    Le 09/11/2026 |a 16:43, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?

    You have merely REPHRASED THE SAME CLAIM.

    You have not PROVED IT.

    The words "would never stop running" are precisely the part that
    requires justification.


    On 11/2/2026 8:50 AM, Python wrote:
    WHILE THE SIMULATION CONTINUES,
    DD DOES NOT REACH ITS RETURN.


    You already conceded that.

    Does not reach its return means never halts
    would never stop running means never halts

    Peter,

    -a-a "You already conceded that."

    NO.

    I conceded EXACTLY this:

    -a-a WHILE THE SIMULATION CONTINUES,
    -a-a DD DOES NOT REACH ITS RETURN.

    You now write:

    -a-a "Does not reach its return means never halts"

    WHERE THE FUCK DID "NEVER" COME FROM?

    A program that has not reached its return YET may reach it later.

    A simulation that has been aborted cannot tell us, merely from its lack
    of a return before abortion, whether the simulated program would
    eventually halt.

    You keep silently deleting the qualification from my statement, then pretending I agreed with your stronger conclusion.

    I DID NOT.

    And there is an even more fundamental distinction you keep ignoring:

    When the OUTER HHH aborts its simulation of DD, that does not mean the
    INNER HHH has returned a value to DD.

    Those are DIFFERENT invocations.

    So, once again:

    What EXACT property of DD's execution proves that it would never reach
    its return if the simulation continued without abortion?

    Not a quotation from me.

    Not a definition of "halt".

    Not another paraphrase of "unless aborted".

    A PROOF.

    Until you provide one, your claim that HHH correctly determines DD's non-termination remains unsupported.


    Yeah. And why do you put up with PO's nonsense?
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 21:29:55 2026
    From Newsgroup: comp.ai.philosophy

    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a "simulated D would never stop running
    -a-a-a unless [simulation is] aborted"

    becomes:

    -a-a "simulated D would never stop running
    -a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    is translated into
    "simulated D would never stop running while being simulated"
    [would never stop running]
    is translated into
    never halts

    [simulated D would never stop running unless aborted]
    becomes
    "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    > WHILE THE SIMULATION CONTINUES,
    > DD DOES NOT REACH ITS RETURN.
    >
    [REACH ITS RETURN]
    is translated into
    HALT

    On 11/2/2026 8:50 AM, Python wrote:
    > WHILE THE SIMULATION CONTINUES,
    > DD DOES NOT REACH ITS RETURN.
    >
    is translated into
    WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    (1) Simulated D would never halt
    while being simulated.

    (2) WHILE THE SIMULATION CONTINUES,
    DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    I HAVE NO OBJECTION TO THAT.

    But you are still missing the essential distinction.

    My statement (2) concerned the simulation ACTUALLY PERFORMED, up to the
    point where it was aborted.

    During that execution, DD did not halt.

    TRUE.

    Your statement (1), however, claims that DD would NEVER halt, even if the simulation were allowed to continue indefinitely.

    THAT IS A STRONGER CLAIM.

    And it is precisely what you have to prove.

    Consider a simulation stopped after 100 steps of a program that would halt after 1,000 steps.

    Throughout the simulation actually performed, the program does not halt.

    Yet it is FALSE that the program would never halt if simulation continued.

    Now, perhaps you can establish that DD is different.

    Perhaps you can prove that its execution would continue indefinitely.

    THEN DO SO.

    But you cannot obtain that proof by translating "return" into "halt" or rearranging the words "while being simulated".

    The mathematical question is not whether (1) and (2) can be made to SOUND equivalent.

    It is whether HHH has established their UNIVERSAL, counterfactual interpretation rather than merely observed a finite prefix of execution.

    THAT IS WHAT YOUR SIPser QUOTATION REQUIRES.

    You have now spent several days proving that two English sentences can
    mean the same thing.

    Congratulations.

    NOW PROVE THAT WHAT THEY ASSERT IS TRUE.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 13:41:11 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 1:29 PM, Python wrote:
    [...]
    Consider a simulation stopped after 100 steps of a program that would
    halt after 1,000 steps.
    Right! PO would chops the legs off a runner saying it was running into infinity. The runner, with no legs now, says I was running to the god
    damn bathroom! Bad fish last night! Now, he has no legs, thanks to the
    evil moron PO?

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 17:14:50 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    -a-a (1) Simulated D would never halt
    -a-a-a-a-a-a while being simulated.

    -a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    I HAVE NO OBJECTION TO THAT.


    So we are done.
    I translated what what Professor Sipser agreed to into (1)
    and I translated what what you agreed to into (2)
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 23:35:57 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 00:14, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    -a-a (1) Simulated D would never halt
    -a-a-a-a-a-a while being simulated.

    -a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    I HAVE NO OBJECTION TO THAT.


    So we are done.
    I translated what what Professor Sipser agreed to into (1)
    and I translated what what you agreed to into (2)

    Peter,

    "So we are done."

    NO, YOU FUCKING IDIOT.

    You have established that two sentences CAN mean the same thing.

    YOU HAVE NOT ESTABLISHED THAT WHAT THEY SAY IS TRUE.

    And you certainly haven't proved that HHH CORRECTLY DETERMINES it.

    Sipser's statement begins with **IF**.

    IF H correctly determines non-termination.

    THAT IS THE FUCKING PREMISE YOU HAVE TO PROVE.

    My agreement concerned the simulation ACTUALLY PERFORMED, not an infinite execution that you have never demonstrated.

    You have spent DAYS playing with English words while systematically
    evading the mathematical question.

    **A PARAPHRASE IS NOT A PROOF.**

    And declaring victory over your own vocabulary exercise is frankly
    pathetic.

    WE ARE DONE WHEN YOU PROVIDE A PROOF.

    NOT WHEN YOU RUN OUT OF SYNONYMS.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 17:55:39 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 5:35 PM, Python wrote:
    Le 10/11/2026 |a 00:14, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    I HAVE NO OBJECTION TO THAT.


    So we are done.
    I translated what what Professor Sipser agreed to into (1)
    and I translated what what you agreed to into (2)

    Peter,

    -a-a "So we are done."

    NO, YOU FUCKING IDIOT.

    You have established that two sentences CAN mean the same thing.


    The one that you agreed to and the one that
    satisfies the Professor Sipser approved criteria.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 23:59:42 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 00:55, olcott a |-crit :
    On 11/9/2026 5:35 PM, Python wrote:
    Le 10/11/2026 |a 00:14, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly. >>>>
    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    I HAVE NO OBJECTION TO THAT.


    So we are done.
    I translated what what Professor Sipser agreed to into (1)
    and I translated what what you agreed to into (2)

    Peter,

    -a-a "So we are done."

    NO, YOU FUCKING IDIOT.

    You have established that two sentences CAN mean the same thing.


    The one that you agreed to and the one that
    satisfies the Professor Sipser approved criteria.

    Peter,

    NO, FOR FUCK'S SAKE!

    I agreed that DD DID NOT HALT DURING THE SIMULATION ACTUALLY PERFORMED.

    Sipser's condition requires HHH to CORRECTLY DETERMINE that DD WOULD NEVER HALT if the simulation continued without abortion.

    **THOSE ARE NOT THE SAME CLAIM.**

    A program can run for a million steps without halting and halt on the next one.

    Your endless paraphrasing does not eliminate that possibility.

    You have NOT proved that HHH correctly determines non-termination.

    You have NOT satisfied Sipser's hypothesis.

    And you have NOT obtained my agreement to either claim.

    **STOP LYING ABOUT WHAT I CONCEDED.**

    You have a missing proof, Peter, not a vocabulary problem.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 18:05:34 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 5:59 PM, Python wrote:
    Le 10/11/2026 |a 00:55, olcott a |-crit :
    On 11/9/2026 5:35 PM, Python wrote:
    Le 10/11/2026 |a 00:14, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared
    directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    I HAVE NO OBJECTION TO THAT.


    So we are done.
    I translated what what Professor Sipser agreed to into (1)
    and I translated what what you agreed to into (2)

    Peter,

    -a-a-a "So we are done."

    NO, YOU FUCKING IDIOT.

    You have established that two sentences CAN mean the same thing.


    The one that you agreed to and the one that
    satisfies the Professor Sipser approved criteria.

    Peter,

    NO, FOR FUCK'S SAKE!

    (1) Was correctly derived from the Professor Sipser approved exact words
    (2) Was derived from your exact words.
    No meanings were changed, just a change of words.
    You agreed that (1) and (2) have the same meaning.

    FOR FUCK'S SAKE!
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 00:16:07 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 01:05, olcott a |-crit :
    On 11/9/2026 5:59 PM, Python wrote:
    Le 10/11/2026 |a 00:55, olcott a |-crit :
    On 11/9/2026 5:35 PM, Python wrote:
    Le 10/11/2026 |a 00:14, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared
    directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    I HAVE NO OBJECTION TO THAT.


    So we are done.
    I translated what what Professor Sipser agreed to into (1)
    and I translated what what you agreed to into (2)

    Peter,

    -a-a-a "So we are done."

    NO, YOU FUCKING IDIOT.

    You have established that two sentences CAN mean the same thing.


    The one that you agreed to and the one that
    satisfies the Professor Sipser approved criteria.

    Peter,

    NO, FOR FUCK'S SAKE!

    (1) Was correctly derived from the Professor Sipser approved exact words
    (2) Was derived from your exact words.
    No meanings were changed, just a change of words.
    You agreed that (1) and (2) have the same meaning.

    FOR FUCK'S SAKE!

    Peter,

    "No meanings were changed, just a change of words."

    BULLSHIT.

    What you call a "derivation" is a FALSIFICATION of what I actually agreed
    to.

    I agreed that DD did not return DURING THE SIMULATION ACTUALLY PERFORMED.

    You turned that into a claim that DD WOULD NEVER RETURN if the simulation continued indefinitely.

    YOU CHANGED THE MEANING.

    And you conveniently dropped the essential requirement from Sipser's statement:

    "H CORRECTLY DETERMINES..."

    WHERE THE FUCK IS YOUR PROOF THAT HHH DOES?

    An equivalence between two sentences does not establish the truth of
    either, let alone prove that HHH correctly determines non-termination.

    You are deliberately presenting my limited agreement as an endorsement of
    a conclusion I have REPEATEDLY rejected.

    That is not a derivation.

    THAT IS MISREPRESENTATION.

    And after being corrected so many times, you have no excuse for continuing
    to attribute that claim to me.

    SHAME ON YOU, PETER.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 18:38:38 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    -a-a (1) Simulated D would never halt
    -a-a-a-a-a-a while being simulated.

    -a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    That is too weak. Does mean exactly the same thing.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 00:40:11 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 01:38, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    -a-a (1) Simulated D would never halt
    -a-a-a-a-a-a while being simulated.

    -a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    That is too weak. Does mean exactly the same thing.

    Peter,

    "Does mean exactly the same thing."

    BULLSHIT.

    And STOP SNIPPING MY REPLIES to conceal the qualifications you keep
    ignoring.

    I wrote:

    "As English sentences, these CAN express
    the same proposition."

    CAN, Peter. NOT NECESSARILY DO.

    My statement concerned the FINITE SIMULATION ACTUALLY PERFORMED.

    Sipser's hypothesis concerns what WOULD HAPPEN if the simulation continued WITHOUT ABORTION, and requires H to CORRECTLY DETERMINE that outcome.

    You have silently changed the scope of my statement, then pretended I
    endorsed your conclusion.

    THAT IS NOT LOGICAL DERIVATION.

    THAT IS FALSIFICATION.

    And even if your two sentences were perfectly equivalent, their
    equivalence would NOT prove their truth.

    FOR FUCK'S SAKE.

    STOP CHERRY-PICKING MY WORDS.

    STOP MISREPRESENTING MY AGREEMENT.

    AND PRODUCE THE FUCKING PROOF THAT HHH CORRECTLY DETERMINES
    NON-TERMINATION.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 18:50:23 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 6:40 PM, Python wrote:
    Le 10/11/2026 |a 01:38, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    That is too weak. Does mean exactly the same thing.

    Peter,

    -a-a "Does mean exactly the same thing."

    BULLSHIT.

    And STOP SNIPPING MY REPLIES to conceal the qualifications you keep ignoring.

    I wrote:

    -a-a "As English sentences, these CAN express
    -a-a-a the same proposition."

    CAN, Peter. NOT NECESSARILY DO.


    Try and show a valid counter-example that categorically
    cannot possibly exist.

    My statement concerned the FINITE SIMULATION ACTUALLY PERFORMED.

    Sipser's hypothesis concerns what WOULD HAPPEN if the simulation
    continued WITHOUT ABORTION, and requires H to CORRECTLY DETERMINE that outcome.

    You have silently changed the scope of my statement, then pretended I endorsed your conclusion.

    THAT IS NOT LOGICAL DERIVATION.

    THAT IS FALSIFICATION.

    And even if your two sentences were perfectly equivalent, their
    equivalence would NOT prove their truth.

    FOR FUCK'S SAKE.

    STOP CHERRY-PICKING MY WORDS.

    STOP MISREPRESENTING MY AGREEMENT.

    AND PRODUCE THE FUCKING PROOF THAT HHH CORRECTLY DETERMINES NON- TERMINATION.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 00:53:43 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 01:50, olcott a |-crit :
    On 11/9/2026 6:40 PM, Python wrote:
    Le 10/11/2026 |a 01:38, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly. >>>>
    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    That is too weak. Does mean exactly the same thing.

    Peter,

    -a-a "Does mean exactly the same thing."

    BULLSHIT.

    And STOP SNIPPING MY REPLIES to conceal the qualifications you keep
    ignoring.

    I wrote:

    -a-a "As English sentences, these CAN express
    -a-a-a the same proposition."

    CAN, Peter. NOT NECESSARILY DO.


    Try and show a valid counter-example that categorically
    cannot possibly exist.

    Peter,

    "Try and show a valid counter-example
    that categorically cannot possibly exist."

    WHAT THE FUCK?

    You claim that a counterexample CANNOT POSSIBLY EXIST.

    THEN PROVE IT.

    You don't get to declare your conclusion true and demand that everyone
    else disprove it.

    That's called SHIFTING THE BURDEN OF PROOF.

    And we don't even need a counterexample to expose your logical error.

    A program that halts after 1,000 steps does not halt during a simulation aborted after 100 steps.

    YET IT HALTS.

    Therefore:

    DID NOT HALT BEFORE ABORTION

    does NOT imply:

    WOULD NEVER HALT WITHOUT ABORTION.

    If you claim that DD is a special case for which HHH can establish the stronger conclusion, PROVIDE THE PROOF.

    Your repeated quotations of my words do not provide it.

    Your paraphrases do not provide it.

    Your declarations that counterexamples are impossible do not provide it.

    FOR FUCK'S SAKE, PETER.

    YOU ARE THE ONE MAKING THE CLAIM.

    YOU HAVE THE BURDEN OF PROOF.

    STOP PRETENDING OTHERWISE.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Nov 9 19:02:48 2026
    From Newsgroup: comp.ai.philosophy

    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    -a-a (1) Simulated D would never halt
    -a-a-a-a-a-a while being simulated.

    -a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 10:50:26 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    -a-a (1) Simulated D would never halt
    -a-a-a-a-a-a while being simulated.

    -a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.

    Now evaluate:

    (1) Simulated D would NEVER halt while being simulated.

    FALSE. Continue the simulation for another 900 steps and D halts.

    (2) WHILE THE SIMULATION CONTINUES,
    D DOES NOT HALT.

    TRUE of the simulation actually performed: D does not halt during those
    100 steps.

    THERE IS YOUR COUNTEREXAMPLE.

    One proposition concerns a finite execution actually observed.

    The other concerns what would happen if execution continued without
    abortion.

    If you interpret BOTH propositions as referring to an unlimited execution, then yes, they are equivalent.

    BUT THAT IS NOT WHAT I AGREED TO.

    You have been told this repeatedly.

    And before you start screaming that my example is not DD: it is a counterexample to your CLAIMED LOGICAL EQUIVALENCE, not a proof that DD
    halts.

    If you want to establish non-termination specifically for DD, PROVIDE THE FUCKING PROOF.

    You cannot manufacture my agreement by systematically ignoring what I
    actually said.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 08:57:14 2026
    From Newsgroup: comp.ai.philosophy

    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Now evaluate:

    -a-a (1) Simulated D would NEVER halt while being simulated.

    FALSE. Continue the simulation for another 900 steps and D halts.

    -a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a D DOES NOT HALT.

    TRUE of the simulation actually performed: D does not halt during those
    100 steps.

    THERE IS YOUR COUNTEREXAMPLE.

    One proposition concerns a finite execution actually observed.

    The other concerns what would happen if execution continued without abortion.

    If you interpret BOTH propositions as referring to an unlimited
    execution, then yes, they are equivalent.

    BUT THAT IS NOT WHAT I AGREED TO.

    You have been told this repeatedly.

    And before you start screaming that my example is not DD: it is a counterexample to your CLAIMED LOGICAL EQUIVALENCE, not a proof that DD halts.

    If you want to establish non-termination specifically for DD, PROVIDE
    THE FUCKING PROOF.

    You cannot manufacture my agreement by systematically ignoring what I actually said.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 15:38:39 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly. >>>>
    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY PRETEND
    IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much
    stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    "There does not exist ANY implementation..."

    "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION CONTINUES.

    You have transformed that into a universal claim about EVERY possible implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 10:15:09 2026
    From Newsgroup: comp.ai.philosophy

    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared
    directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY PRETEND
    IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much
    stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a "There does not exist ANY implementation..."

    -a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION CONTINUES.

    You have transformed that into a universal claim about EVERY possible implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 16:16:18 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted]
    -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared
    directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY PRETEND
    IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much
    stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a "There does not exist ANY implementation..."

    -a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION CONTINUES. >>
    You have transformed that into a universal claim about EVERY possible
    implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition whose
    derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition instead
    of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    int Halt_Status = HHH(DD);

    if (Halt_Status)
    HERE: goto HERE;

    return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify PRECISELY
    what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict that quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 16:17:50 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared
    directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY PRETEND >>> IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much
    stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a "There does not exist ANY implementation..."

    -a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION CONTINUES. >>>
    You have transformed that into a universal claim about EVERY possible
    implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition whose >>> derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    int Halt_Status = HHH(DD);

    if (Halt_Status)
    HERE: goto HERE;

    return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify PRECISELY what
    additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict that quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH invoked
    by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode:

    int HHH(ptr P)
    {
    static int depth = 0;

    if (depth > 0)
    return 0;

    depth++;
    simulate(P);
    depth--;

    return 1;
    }

    Here, simulate(P) faithfully simulates the execution of P, including the
    code of HHH itself and its access to the simulated state.

    The execution proceeds as follows:

    1. The outer HHH(DD) increments depth to 1 and starts simulating DD.

    2. The simulated DD invokes HHH(DD).

    3. This simulated invocation sees depth == 1 and returns 0.

    4. The simulated DD does not enter its infinite loop.

    5. The simulated DD reaches its return statement.

    6. The outer HHH completes its simulation and returns 1.

    SAME implementation of HHH.

    SAME source code of DD.

    Faithful simulation according to the operational semantics of C.

    And DD reaches its simulated return statement in a finite number of steps.

    This is NOT a universal halt decider.

    IT DOES NOT NEED TO BE ONE.

    Your proposition quantifies over ANY implementation of HHH that simulates
    DD.

    If you require HHH to satisfy additional properties, STATE THEM.

    In particular, if you require every invocation of HHH to be a correct halt decider, you are introducing a condition that your original proposition
    did not contain.

    And if you require a total, universally correct halt decider, you are back
    to the impossible hypothesis of the Halting Theorem.

    There is no mystery here.

    Different invocations of the SAME function can behave differently because
    they execute in different states.

    This is elementary programming.

    Your universal claim, as stated, is FALSE.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 10:29:37 2026
    From Newsgroup: comp.ai.philosophy

    On 11/10/2026 10:16 AM, Python wrote:
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated"

    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared
    directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
    PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much
    stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION
    CONTINUES.

    You have transformed that into a universal claim about EVERY possible
    implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition
    whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.


    I think that you did. I will look that up later on.
    If you did it was on Sunday November 1.

    And FINALLY, you are asking whether I agree with this proposition
    instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a int Halt_Status = HHH(DD);

    -a-a if (Halt_Status)
    -a-a-a-a-a-a HERE: goto HERE;

    -a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify
    PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict that quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.
    --
    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,comp.ai.philosophy on Tue Nov 10 10:31:17 2026
    From Newsgroup: comp.ai.philosophy

    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>>>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared >>>>>>>> directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
    PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much
    stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION
    CONTINUES.

    You have transformed that into a universal claim about EVERY
    possible implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>
    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition
    whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition
    instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but
    whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a-a int Halt_Status = HHH(DD);

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    -a-a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify
    PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict that
    quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH
    invoked by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode:

    -a-a int HHH(ptr P)
    -a-a {
    -a-a-a-a-a-a static int depth = 0;

    -a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a return 0;

    -a-a-a-a-a-a depth++;
    -a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a depth--;

    -a-a-a-a-a-a return 1;
    -a-a }

    Here, simulate(P) faithfully simulates the execution of P, including the code of HHH itself and its access to the simulated state.

    The execution proceeds as follows:

    1. The outer HHH(DD) increments depth to 1 and starts simulating DD.

    2. The simulated DD invokes HHH(DD).

    3. This simulated invocation sees depth == 1 and returns 0.

    4. The simulated DD does not enter its infinite loop.

    5. The simulated DD reaches its return statement.

    6. The outer HHH completes its simulation and returns 1.

    SAME implementation of HHH.

    SAME source code of DD.

    Faithful simulation according to the operational semantics of C.

    And DD reaches its simulated return statement in a finite number of steps.

    This is NOT a universal halt decider.

    IT DOES NOT NEED TO BE ONE.

    Your proposition quantifies over ANY implementation of HHH that
    simulates DD.

    If you require HHH to satisfy additional properties, STATE THEM.

    In particular, if you require every invocation of HHH to be a correct
    halt decider, you are introducing a condition that your original
    proposition did not contain.

    And if you require a total, universally correct halt decider, you are
    back to the impossible hypothesis of the Halting Theorem.

    There is no mystery here.

    Different invocations of the SAME function can behave differently
    because they execute in different states.

    This is elementary programming.

    Your universal claim, as stated, is FALSE.


    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    So do you agree with that now? I have an 8 hour infusion
    today thus no time to go over tiny details.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 16:36:02 2026
    From Newsgroup: comp.ai.philosophy

    Le 10/11/2026 |a 17:31, olcott a |-crit :
    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared >>>>>>>>> directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition. >>>>>>>>>
    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
    PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much
    stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION
    CONTINUES.

    You have transformed that into a universal claim about EVERY
    possible implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>>
    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition
    whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition
    instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but
    whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a-a int Halt_Status = HHH(DD);

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    -a-a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify
    PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict that
    quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH
    invoked by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode:

    -a-a int HHH(ptr P)
    -a-a {
    -a-a-a-a-a-a static int depth = 0;

    -a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a return 0;

    -a-a-a-a-a-a depth++;
    -a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a depth--;

    -a-a-a-a-a-a return 1;
    -a-a }

    Here, simulate(P) faithfully simulates the execution of P, including the
    code of HHH itself and its access to the simulated state.

    The execution proceeds as follows:

    1. The outer HHH(DD) increments depth to 1 and starts simulating DD.

    2. The simulated DD invokes HHH(DD).

    3. This simulated invocation sees depth == 1 and returns 0.

    4. The simulated DD does not enter its infinite loop.

    5. The simulated DD reaches its return statement.

    6. The outer HHH completes its simulation and returns 1.

    SAME implementation of HHH.

    SAME source code of DD.

    Faithful simulation according to the operational semantics of C.

    And DD reaches its simulated return statement in a finite number of steps. >>
    This is NOT a universal halt decider.

    IT DOES NOT NEED TO BE ONE.

    Your proposition quantifies over ANY implementation of HHH that
    simulates DD.

    If you require HHH to satisfy additional properties, STATE THEM.

    In particular, if you require every invocation of HHH to be a correct
    halt decider, you are introducing a condition that your original
    proposition did not contain.

    And if you require a total, universally correct halt decider, you are
    back to the impossible hypothesis of the Halting Theorem.

    There is no mystery here.

    Different invocations of the SAME function can behave differently
    because they execute in different states.

    This is elementary programming.

    Your universal claim, as stated, is FALSE.


    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    So do you agree with that now? I have an 8 hour infusion
    today thus no time to go over tiny details.

    Peter,

    "So do you agree with that now?"

    NO.

    WHAT THE FUCK?

    I have just provided an explicit counterexample to that very proposition.

    An implementation of HHH.

    The SAME implementation for the outer and inner invocations.

    A faithful simulation of DD according to the operational semantics of C.

    And a finite execution reaching DD's simulated return statement.

    You have quoted my ENTIRE counterexample and then simply repeated the proposition it refutes.

    SERIOUSLY?

    "no time to go over tiny details."

    A COUNTEREXAMPLE TO YOUR UNIVERSAL CLAIM IS NOT A TINY DETAIL.

    It is a refutation.

    I sincerely wish you well with your infusion. There is no urgency to
    reply.

    But when you have time, address the counterexample.

    Repeating your proposition does not make it true.

    And it certainly does not make me agree with it.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Tue Nov 10 10:48:48 2026
    From Newsgroup: comp.ai.philosophy

    On 11/10/2026 10:36 AM, Python wrote:
    Le 10/11/2026 |a 17:31, olcott a |-crit :
    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted] >>>>>>>>>>> -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being >>>>>>>>>>> simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>
    (1) "simulated D would never halt while being simulated" >>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared >>>>>>>>>> directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition. >>>>>>>>>>
    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
    PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much >>>>>> stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION
    CONTINUES.

    You have transformed that into a universal claim about EVERY
    possible implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR
    DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition >>>>>> whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition
    instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but
    whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a-a int Halt_Status = HHH(DD);

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    -a-a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify
    PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict
    that quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH
    invoked by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode:

    -a-a-a int HHH(ptr P)
    -a-a-a {
    -a-a-a-a-a-a-a static int depth = 0;

    -a-a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a-a return 0;

    -a-a-a-a-a-a-a depth++;
    -a-a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a-a depth--;

    -a-a-a-a-a-a-a return 1;
    -a-a-a }

    Here, simulate(P) faithfully simulates the execution of P, including
    the code of HHH itself and its access to the simulated state.

    The execution proceeds as follows:

    1. The outer HHH(DD) increments depth to 1 and starts simulating DD.

    2. The simulated DD invokes HHH(DD).

    3. This simulated invocation sees depth == 1 and returns 0.

    4. The simulated DD does not enter its infinite loop.

    5. The simulated DD reaches its return statement.

    6. The outer HHH completes its simulation and returns 1.

    SAME implementation of HHH.

    SAME source code of DD.

    Faithful simulation according to the operational semantics of C.

    And DD reaches its simulated return statement in a finite number of
    steps.

    This is NOT a universal halt decider.

    IT DOES NOT NEED TO BE ONE.

    Your proposition quantifies over ANY implementation of HHH that
    simulates DD.

    If you require HHH to satisfy additional properties, STATE THEM.

    In particular, if you require every invocation of HHH to be a correct
    halt decider, you are introducing a condition that your original
    proposition did not contain.

    And if you require a total, universally correct halt decider, you are
    back to the impossible hypothesis of the Halting Theorem.

    There is no mystery here.

    Different invocations of the SAME function can behave differently
    because they execute in different states.

    This is elementary programming.

    Your universal claim, as stated, is FALSE.


    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    So do you agree with that now? I have an 8 hour infusion
    today thus no time to go over tiny details.

    Peter,

    -a-a "So do you agree with that now?"

    NO.

    WHAT THE FUCK?


    I am going for an 8 hour infusion in a few minutes.
    I will look up what you said on Nov 1.
    --
    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,comp.ai.philosophy on Tue Nov 10 22:41:00 2026
    From Newsgroup: comp.ai.philosophy

    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated" >>>>>>>>> -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared >>>>>>>> directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition.

    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
    PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much
    stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION
    CONTINUES.

    You have transformed that into a universal claim about EVERY
    possible implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>
    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition
    whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition
    instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but
    whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a-a int Halt_Status = HHH(DD);

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    -a-a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify
    PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict that
    quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH
    invoked by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode:

    -a-a int HHH(ptr P)
    -a-a {
    -a-a-a-a-a-a static int depth = 0;

    -a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a return 0;

    -a-a-a-a-a-a depth++;
    -a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a depth--;

    -a-a-a-a-a-a return 1;
    -a-a }

    Here, simulate(P) faithfully simulates the execution of P, including the code of HHH itself and its access to the simulated state.

    The execution proceeds as follows:

    int HHHH(ptr P);

    int DDDD()
    {
    int Halt_Status = HHHH(DDDD);
    if (Halt_Status)
    HERE: goto HERE;
    return Halt_Status;
    }

    int simulateXXX(ptr P)
    {
    P();
    return 1;
    }

    int HHHH(ptr P)
    {
    static int depth = 0;

    if (depth > 0)
    return 0;

    depth++;
    simulateXXX(P);
    depth--;
    return 1;
    }

    int main()
    {
    Output("Input_Halts = ", HHHH(DDDD));
    return 0;
    }

    I can give the the machine code trace.
    It is quite verbose. The simulated DDDD
    never reaches its own simulated return
    and HHHH returns the correct halt status.

    dbush could see that the meaning of these words made them true:

    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    (1) This seems dead obvious to me.
    (2) The above words
    *There does not exist any implementation of C function HHH*
    that dbush composed are better than my own best words.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 12:23:30 2026
    From Newsgroup: comp.ai.philosophy

    Le 11/11/2026 |a 05:41, olcott a |-crit :
    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted]
    -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    (1) "simulated D would never halt while being simulated"
    (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared >>>>>>>>> directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition. >>>>>>>>>
    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
    PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much
    stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION
    CONTINUES.

    You have transformed that into a universal claim about EVERY
    possible implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>>
    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition
    whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition
    instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but
    whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a-a int Halt_Status = HHH(DD);

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    -a-a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify
    PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict that
    quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH
    invoked by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode:

    -a-a int HHH(ptr P)
    -a-a {
    -a-a-a-a-a-a static int depth = 0;

    -a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a return 0;

    -a-a-a-a-a-a depth++;
    -a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a depth--;

    -a-a-a-a-a-a return 1;
    -a-a }

    Here, simulate(P) faithfully simulates the execution of P, including the
    code of HHH itself and its access to the simulated state.

    The execution proceeds as follows:

    int HHHH(ptr P);

    int DDDD()
    {
    int Halt_Status = HHHH(DDDD);
    if (Halt_Status)
    HERE: goto HERE;
    return Halt_Status;
    }

    int simulateXXX(ptr P)
    {
    P();
    return 1;
    }

    int HHHH(ptr P)
    {
    static int depth = 0;

    if (depth > 0)
    return 0;

    depth++;
    simulateXXX(P);
    depth--;
    return 1;
    }

    int main()
    {
    Output("Input_Halts = ", HHHH(DDDD));
    return 0;
    }

    I can give the the machine code trace.
    It is quite verbose. The simulated DDDD
    never reaches its own simulated return
    and HHHH returns the correct halt status.

    dbush could see that the meaning of these words made them true:

    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    (1) This seems dead obvious to me.
    (2) The above words
    *There does not exist any implementation of C function HHH*
    that dbush composed are better than my own best words.

    Peter,

    THANK YOU.

    You have just provided a concrete C program that REFUTES YOUR OWN CLAIM.

    Let's execute YOUR code.

    Initially:

    depth = 0

    The outer HHHH(DDDD) executes:

    depth++;

    Now:

    depth = 1

    Then:

    simulateXXX(DDDD);

    which executes:

    DDDD();

    Inside DDDD:

    Halt_Status = HHHH(DDDD);

    This nested invocation executes:

    if (depth > 0)
    return 0;

    Since depth == 1, HHHH returns 0.

    Back inside DDDD:

    Halt_Status == 0

    Therefore:

    if (Halt_Status)
    HERE: goto HERE;

    does NOT enter the loop.

    And the very next statement is:

    return Halt_Status;

    DDDD RETURNS ZERO.

    The outer HHHH then decrements depth and returns 1.

    So YOUR OWN PROGRAM establishes:

    DDDD reaches its return statement.

    HHHH(DDDD) returns 1.

    Both executions terminate.

    The returned halt status is correct.

    And yet you write:

    "The simulated DDDD never reaches
    its own simulated return"

    WHAT THE FUCK ARE YOU TALKING ABOUT?

    Your simulateXXX calls DDDD directly rather than interpreting its machine instructions. But the actual C execution is perfectly clear.

    YES, PLEASE PROVIDE THE MACHINE CODE TRACE.

    In particular, show us where DDDD supposedly fails to execute its return instruction.

    Because according to the C code YOU JUST POSTED, it MUST reach that
    return.

    You have managed to construct a counterexample to your own universal
    claim, POST IT YOURSELF, and then declare that it proves the exact
    opposite.

    That is quite an achievement.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Alan Mackenzie@acm@muc.de to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 12:39:09 2026
    From Newsgroup: comp.ai.philosophy

    [ Followup-To: set ]
    In comp.theory Python <jpierre.messager@gmail.com> wrote:
    Le 10/11/2026 |a 17:31, olcott a |-crit :
    On 11/10/2026 10:17 AM, Python wrote:
    [ .... ]
    Consider the following implementation, expressed in C-like pseudocode:
    -a-a int HHH(ptr P)
    -a-a {
    -a-a-a-a-a-a static int depth = 0;
    -a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a return 0;
    -a-a-a-a-a-a depth++;
    -a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a depth--;
    -a-a-a-a-a-a return 1;
    -a-a }
    [ .... ]
    Your universal claim, as stated, is FALSE.
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.
    [ .... ]
    Peter,
    "So do you agree with that now?"
    NO.
    WHAT THE FUCK?
    I have just provided an explicit counterexample to that very proposition.
    You've not yet grasped the fact that Peter Olcott doesn't understand the concept of a counterexample. His intellect is insufficiently developed
    for that. Neither does he grasp the concept of a mathematical proof.
    You might as well be writing in Chinese for all the good it will do you.
    An implementation of HHH.
    The SAME implementation for the outer and inner invocations.
    A faithful simulation of DD according to the operational semantics of C.
    And a finite execution reaching DD's simulated return statement.
    You have quoted my ENTIRE counterexample and then simply repeated the proposition it refutes.
    SERIOUSLY?
    You might as well be screaming at a 5 year old child. He wouldn't
    understand the concept of a counterexample either.
    Other posters and lurkers here immediately see you're right.
    "no time to go over tiny details."
    A COUNTEREXAMPLE TO YOUR UNIVERSAL CLAIM IS NOT A TINY DETAIL.
    It is a refutation.
    [ .... ]
    Repeating your proposition does not make it true.
    And it certainly does not make me agree with it.
    --
    Alan Mackenzie (Nuremberg, Germany).
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 07:23:08 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 6:23 AM, Python wrote:
    Le 11/11/2026 |a 05:41, olcott a |-crit :
    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted] >>>>>>>>>>> -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being >>>>>>>>>>> simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>
    (1) "simulated D would never halt while being simulated" >>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared >>>>>>>>>> directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition. >>>>>>>>>>
    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY
    PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much >>>>>> stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION
    CONTINUES.

    You have transformed that into a universal claim about EVERY
    possible implementation of HHH and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR
    DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE.

    You reject it because it does not satisfy the stronger proposition >>>>>> whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition
    instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but
    whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a-a int Halt_Status = HHH(DD);

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    -a-a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify
    PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict
    that quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH
    invoked by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode:

    -a-a-a int HHH(ptr P)
    -a-a-a {
    -a-a-a-a-a-a-a static int depth = 0;

    -a-a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a-a return 0;

    -a-a-a-a-a-a-a depth++;
    -a-a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a-a depth--;

    -a-a-a-a-a-a-a return 1;
    -a-a-a }

    Here, simulate(P) faithfully simulates the execution of P, including
    the code of HHH itself and its access to the simulated state.

    The execution proceeds as follows:

    int HHHH(ptr P);

    int DDDD()
    {
    -a-a int Halt_Status = HHHH(DDDD);
    -a-a if (Halt_Status)
    -a-a-a-a HERE: goto HERE;
    -a-a return Halt_Status;
    }

    int simulateXXX(ptr P)
    {
    -a-a P();
    -a-a return 1;
    }

    int HHHH(ptr P)
    {
    -a-a static int depth = 0;

    -a-a if (depth > 0)
    -a-a-a-a return 0;

    -a-a depth++;
    -a-a simulateXXX(P);
    -a-a depth--;
    -a-a return 1;
    }

    int main()
    {
    -a-a Output("Input_Halts = ", HHHH(DDDD));
    -a-a return 0;
    }

    I can give the the machine code trace.
    It is quite verbose. The simulated DDDD
    never reaches its own simulated return
    and HHHH returns the correct halt status.

    dbush could see that the meaning of these words made them true:

    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    (1) This seems dead obvious to me.
    (2) The above words
    *There does not exist any implementation of C function HHH*
    that dbush composed are better than my own best words.

    Peter,

    THANK YOU.

    You have just provided a concrete C program that REFUTES YOUR OWN CLAIM.

    Let's execute YOUR code.

    Initially:

    -a-a depth = 0

    The outer HHHH(DDDD) executes:

    -a-a depth++;

    Now:

    -a-a depth = 1

    Then:

    -a-a simulateXXX(DDDD);

    which executes:

    -a-a DDDD();

    Inside DDDD:

    -a-a Halt_Status = HHHH(DDDD);

    This nested invocation executes:

    -a-a if (depth > 0)
    -a-a-a-a-a-a return 0;

    Since depth == 1, HHHH returns 0.

    Back inside DDDD:

    -a-a Halt_Status == 0

    Therefore:

    -a-a if (Halt_Status)
    -a-a-a-a-a-a HERE: goto HERE;

    does NOT enter the loop.

    And the very next statement is:

    -a-a return Halt_Status;

    DDDD RETURNS ZERO.

    The outer HHHH then decrements depth and returns 1.

    So YOUR OWN PROGRAM establishes:

    -a-a DDDD reaches its return statement.

    -a-a HHHH(DDDD) returns 1.

    -a-a Both executions terminate.

    -a-a The returned halt status is correct.

    And yet you write:

    -a-a "The simulated DDDD never reaches
    -a-a-a its own simulated return"

    WHAT THE FUCK ARE YOU TALKING ABOUT?

    Your simulateXXX calls DDDD directly rather than interpreting its
    machine instructions. But the actual C execution is perfectly clear.

    YES, PLEASE PROVIDE THE MACHINE CODE TRACE.

    In particular, show us where DDDD supposedly fails to execute its return instruction.

    Because according to the C code YOU JUST POSTED, it MUST reach that return.

    You have managed to construct a counterexample to your own universal
    claim, POST IT YOURSELF, and then declare that it proves the exact
    opposite.

    That is quite an achievement.

    _HHHH()
    [000021f6] 55 push ebp
    [000021f7] 8bec mov ebp,esp
    [000021f9] 833d0000000000 cmp dword [00000000],+00
    [00002200] 7e04 jng 00002206
    [00002202] 33c0 xor eax,eax
    [00002204] eb2d jmp 00002233
    [00002206] a100000000 mov eax,[00000000]
    [0000220b] 83c001 add eax,+01
    [0000220e] a300000000 mov [00000000],eax
    [00002213] 8b4d08 mov ecx,[ebp+08]
    [00002216] 51 push ecx
    [00002217] e84a000000 call 00002266
    [0000221c] 83c404 add esp,+04
    [0000221f] 8b1500000000 mov edx,[00000000]
    [00002225] 83ea01 sub edx,+01
    [00002228] 891500000000 mov [00000000],edx
    [0000222e] b801000000 mov eax,00000001
    [00002233] 5d pop ebp
    [00002234] c3 ret
    Size in bytes:(0063) [00002234]

    _DDDD()
    [00002236] 55 push ebp
    [00002237] 8bec mov ebp,esp
    [00002239] 51 push ecx
    [0000223a] 6836220000 push 00002236
    [0000223f] e8b2ffffff call 000021f6
    [00002244] 83c404 add esp,+04
    [00002247] 8945fc mov [ebp-04],eax
    [0000224a] 837dfc00 cmp dword [ebp-04],+00
    [0000224e] 7402 jz 00002252
    [00002250] ebfe jmp 00002250
    [00002252] 8b45fc mov eax,[ebp-04]
    [00002255] 8be5 mov esp,ebp
    [00002257] 5d pop ebp
    [00002258] c3 ret
    Size in bytes:(0035) [00002258]

    _simulateXXX()
    [00002266] 55 push ebp
    [00002267] 8bec mov ebp,esp
    [00002269] ff5508 call dword [ebp+08]
    [0000226c] b801000000 mov eax,00000001
    [00002271] 5d pop ebp
    [00002272] c3 ret
    Size in bytes:(0013) [00002272]

    _main()
    [00002276] 55 push ebp
    [00002277] 8bec mov ebp,esp
    [00002279] 6836220000 push 00002236
    [0000227e] e873ffffff call 000021f6
    [00002283] 83c404 add esp,+04
    [00002286] 50 push eax
    [00002287] 6887070000 push 00000787
    [0000228c] e815e5ffff call 000007a6
    [00002291] 83c408 add esp,+08
    [00002294] 33c0 xor eax,eax
    [00002296] 5d pop ebp
    [00002297] c3 ret
    Size in bytes:(0034) [00002297]





    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ============== ============= [00002276][001039d6][00000000] 55 push ebp [00002277][001039d6][00000000] 8bec mov ebp,esp [00002279][001039d2][00002236] 6836220000 push 00002236

    // call HHH(DDDD) [0000227e][001039ce][00002283] e873ffffff call 000021f6 [000021f6][001039ca][001039d6] 55 push ebp [000021f7][001039ca][001039d6] 8bec mov ebp,esp [000021f9][001039ca][001039d6] 833d0000000000 cmp dword [00000000],+00 [00002200][001039ca][001039d6] 7e04 jng 00002206 [00002202][001039ca][001039d6] 33c0 xor eax,eax [00002204][001039ca][001039d6] eb2d jmp 00002233 [00002233][001039ce][00002283] 5d pop ebp [00002234][001039d2][00002236] c3 ret
    // end HHHH [00002283][001039d6][00000000] 83c404 add esp,+04 [00002286][001039d2][00000000] 50 push eax [00002287][001039ce][00000787] 6887070000 push 00000787 [0000228c][001039ce][00000787] e815e5ffff call 000007a6
    Input_Halts = 0
    [00002291][001039d6][00000000] 83c408 add esp,+08 [00002294][001039d6][00000000] 33c0 xor eax,eax [00002296][001039da][90909090] 5d pop ebp [00002297][001039de][90909090] c3 ret
    Number of Instructions Executed(19) == 0 Pages
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 13:30:00 2026
    From Newsgroup: comp.ai.philosophy

    Le 11/11/2026 |a 14:23, olcott a |-crit :
    On 11/11/2026 6:23 AM, Python wrote:
    Le 11/11/2026 |a 05:41, olcott a |-crit :
    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted] >>>>>>>>>>>> -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being >>>>>>>>>>>> simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>
    (1) "simulated D would never halt while being simulated" >>>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared >>>>>>>>>>> directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition. >>>>>>>>>>>
    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY >>>>>>> PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much >>>>>>> stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION >>>>>>> CONTINUES.

    You have transformed that into a universal claim about EVERY
    possible implementation of HHH and EVERY finite number of steps. >>>>>>>
    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR >>>>>>> DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE. >>>>>>>
    You reject it because it does not satisfy the stronger proposition >>>>>>> whose derivation is precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition
    instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but
    whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a-a int Halt_Status = HHH(DD);

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    -a-a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify
    PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict
    that quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH
    invoked by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode: >>>>
    -a-a-a int HHH(ptr P)
    -a-a-a {
    -a-a-a-a-a-a-a static int depth = 0;

    -a-a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a-a return 0;

    -a-a-a-a-a-a-a depth++;
    -a-a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a-a depth--;

    -a-a-a-a-a-a-a return 1;
    -a-a-a }

    Here, simulate(P) faithfully simulates the execution of P, including
    the code of HHH itself and its access to the simulated state.

    The execution proceeds as follows:

    int HHHH(ptr P);

    int DDDD()
    {
    -a-a int Halt_Status = HHHH(DDDD);
    -a-a if (Halt_Status)
    -a-a-a-a HERE: goto HERE;
    -a-a return Halt_Status;
    }

    int simulateXXX(ptr P)
    {
    -a-a P();
    -a-a return 1;
    }

    int HHHH(ptr P)
    {
    -a-a static int depth = 0;

    -a-a if (depth > 0)
    -a-a-a-a return 0;

    -a-a depth++;
    -a-a simulateXXX(P);
    -a-a depth--;
    -a-a return 1;
    }

    int main()
    {
    -a-a Output("Input_Halts = ", HHHH(DDDD));
    -a-a return 0;
    }

    I can give the the machine code trace.
    It is quite verbose. The simulated DDDD
    never reaches its own simulated return
    and HHHH returns the correct halt status.

    dbush could see that the meaning of these words made them true:

    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    (1) This seems dead obvious to me.
    (2) The above words
    *There does not exist any implementation of C function HHH*
    that dbush composed are better than my own best words.

    Peter,

    THANK YOU.

    You have just provided a concrete C program that REFUTES YOUR OWN CLAIM.

    Let's execute YOUR code.

    Initially:

    -a-a depth = 0

    The outer HHHH(DDDD) executes:

    -a-a depth++;

    Now:

    -a-a depth = 1

    Then:

    -a-a simulateXXX(DDDD);

    which executes:

    -a-a DDDD();

    Inside DDDD:

    -a-a Halt_Status = HHHH(DDDD);

    This nested invocation executes:

    -a-a if (depth > 0)
    -a-a-a-a-a-a return 0;

    Since depth == 1, HHHH returns 0.

    Back inside DDDD:

    -a-a Halt_Status == 0

    Therefore:

    -a-a if (Halt_Status)
    -a-a-a-a-a-a HERE: goto HERE;

    does NOT enter the loop.

    And the very next statement is:

    -a-a return Halt_Status;

    DDDD RETURNS ZERO.

    The outer HHHH then decrements depth and returns 1.

    So YOUR OWN PROGRAM establishes:

    -a-a DDDD reaches its return statement.

    -a-a HHHH(DDDD) returns 1.

    -a-a Both executions terminate.

    -a-a The returned halt status is correct.

    And yet you write:

    -a-a "The simulated DDDD never reaches
    -a-a-a its own simulated return"

    WHAT THE FUCK ARE YOU TALKING ABOUT?

    Your simulateXXX calls DDDD directly rather than interpreting its
    machine instructions. But the actual C execution is perfectly clear.

    YES, PLEASE PROVIDE THE MACHINE CODE TRACE.

    In particular, show us where DDDD supposedly fails to execute its return
    instruction.

    Because according to the C code YOU JUST POSTED, it MUST reach that return. >>
    You have managed to construct a counterexample to your own universal
    claim, POST IT YOURSELF, and then declare that it proves the exact
    opposite.

    That is quite an achievement.

    _HHHH()
    [000021f6] 55 push ebp
    [000021f7] 8bec mov ebp,esp
    [000021f9] 833d0000000000 cmp dword [00000000],+00
    [00002200] 7e04 jng 00002206
    [00002202] 33c0 xor eax,eax
    [00002204] eb2d jmp 00002233
    [00002206] a100000000 mov eax,[00000000]
    [0000220b] 83c001 add eax,+01
    [0000220e] a300000000 mov [00000000],eax
    [00002213] 8b4d08 mov ecx,[ebp+08]
    [00002216] 51 push ecx
    [00002217] e84a000000 call 00002266
    [0000221c] 83c404 add esp,+04
    [0000221f] 8b1500000000 mov edx,[00000000]
    [00002225] 83ea01 sub edx,+01
    [00002228] 891500000000 mov [00000000],edx
    [0000222e] b801000000 mov eax,00000001
    [00002233] 5d pop ebp
    [00002234] c3 ret
    Size in bytes:(0063) [00002234]

    _DDDD()
    [00002236] 55 push ebp
    [00002237] 8bec mov ebp,esp
    [00002239] 51 push ecx
    [0000223a] 6836220000 push 00002236
    [0000223f] e8b2ffffff call 000021f6
    [00002244] 83c404 add esp,+04
    [00002247] 8945fc mov [ebp-04],eax
    [0000224a] 837dfc00 cmp dword [ebp-04],+00
    [0000224e] 7402 jz 00002252
    [00002250] ebfe jmp 00002250
    [00002252] 8b45fc mov eax,[ebp-04]
    [00002255] 8be5 mov esp,ebp
    [00002257] 5d pop ebp
    [00002258] c3 ret
    Size in bytes:(0035) [00002258]

    _simulateXXX()
    [00002266] 55 push ebp
    [00002267] 8bec mov ebp,esp
    [00002269] ff5508 call dword [ebp+08]
    [0000226c] b801000000 mov eax,00000001
    [00002271] 5d pop ebp
    [00002272] c3 ret
    Size in bytes:(0013) [00002272]

    _main()
    [00002276] 55 push ebp
    [00002277] 8bec mov ebp,esp
    [00002279] 6836220000 push 00002236
    [0000227e] e873ffffff call 000021f6
    [00002283] 83c404 add esp,+04
    [00002286] 50 push eax
    [00002287] 6887070000 push 00000787
    [0000228c] e815e5ffff call 000007a6
    [00002291] 83c408 add esp,+08
    [00002294] 33c0 xor eax,eax
    [00002296] 5d pop ebp
    [00002297] c3 ret
    Size in bytes:(0034) [00002297]





    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ============== ============= [00002276][001039d6][00000000] 55 push ebp [00002277][001039d6][00000000] 8bec mov ebp,esp [00002279][001039d2][00002236] 6836220000 push 00002236

    // call HHH(DDDD) [0000227e][001039ce][00002283] e873ffffff call 000021f6 [000021f6][001039ca][001039d6] 55 push ebp [000021f7][001039ca][001039d6] 8bec mov ebp,esp [000021f9][001039ca][001039d6] 833d0000000000 cmp dword [00000000],+00 [00002200][001039ca][001039d6] 7e04 jng 00002206 [00002202][001039ca][001039d6] 33c0 xor eax,eax [00002204][001039ca][001039d6] eb2d jmp 00002233 [00002233][001039ce][00002283] 5d pop ebp [00002234][001039d2][00002236] c3 ret
    // end HHHH [00002283][001039d6][00000000] 83c404 add esp,+04 [00002286][001039d2][00000000] 50 push eax [00002287][001039ce][00000787] 6887070000 push 00000787 [0000228c][001039ce][00000787] e815e5ffff call 000007a6
    Input_Halts = 0
    [00002291][001039d6][00000000] 83c408 add esp,+08 [00002294][001039d6][00000000] 33c0 xor eax,eax [00002296][001039da][90909090] 5d pop ebp [00002297][001039de][90909090] c3 ret
    Number of Instructions Executed(19) == 0 Pages

    Peter,

    THANK YOU FOR THE MACHINE CODE TRACE.

    It exposes the problem immediately.

    Look at YOUR trace:

    000021f9 cmp dword [00000000],+00
    00002200 jng 00002206
    00002202 xor eax,eax
    00002204 jmp 00002233

    The conditional jump is NOT taken.

    Therefore, the condition:

    depth > 0

    is TRUE at the very beginning of the OUTER HHHH invocation.

    BUT YOUR SOURCE CODE DECLARES:

    static int depth = 0;

    At the start of the program, depth MUST be zero.

    Consequently, the correct execution must take the branch to 00002206, increment depth, and call simulateXXX(DDDD).

    YOUR TRACE DOES NONE OF THAT.

    It immediately returns zero, without ever calling DDDD.

    Indeed, your entire trace contains only 19 executed instructions!

    So when you claim:

    "The simulated DDDD never reaches
    its own simulated return"

    you are describing a simulation THAT NEVER EVEN STARTED.

    And there is an even more obvious discrepancy.

    Your trace prints:

    Input_Halts = 0

    But your C program, executed with its correctly initialized static
    variable, prints:

    Input_Halts = 1

    because DDDD DOES reach its return statement.

    Your trace is therefore NOT a valid execution of the C program you
    presented from its specified initial state.

    The most likely explanation is that your emulator has not correctly initialized the simulated static storage.

    You have confused a BUG IN YOUR SIMULATOR with a mathematical
    impossibility.

    FOR FUCK'S SAKE, PETER.

    Before claiming to have refuted the Halting Theorem, perhaps make sure
    your emulator can correctly execute a static variable initialized to zero.

    Please show the initial contents of the memory location corresponding to depth, and explain why the first conditional jump is not taken.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From polcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 07:47:08 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 7:30 AM, Python wrote:
    Le 11/11/2026 |a 14:23, olcott a |-crit :
    On 11/11/2026 6:23 AM, Python wrote:
    Le 11/11/2026 |a 05:41, olcott a |-crit :
    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted] >>>>>>>>>>>>> -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being >>>>>>>>>>>>> simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>>
    (1) "simulated D would never halt while being simulated" >>>>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be
    compared directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition. >>>>>>>>>>>>
    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions." >>>>>>>>>>
    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches >>>>>>>>> its own simulated return statement in any N finite number of >>>>>>>>> steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY >>>>>>>> PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a >>>>>>>> much stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION >>>>>>>> CONTINUES.

    You have transformed that into a universal claim about EVERY
    possible implementation of HHH and EVERY finite number of steps. >>>>>>>>
    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR >>>>>>>> DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE. >>>>>>>>
    You reject it because it does not satisfy the stronger
    proposition whose derivation is precisely what is being challenged. >>>>>>>>
    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition >>>>>> instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but >>>>>> whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a-a int Halt_Status = HHH(DD);

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    -a-a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify
    PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict >>>>>> that quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH
    invoked by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode: >>>>>
    -a-a-a int HHH(ptr P)
    -a-a-a {
    -a-a-a-a-a-a-a static int depth = 0;

    -a-a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a-a return 0;

    -a-a-a-a-a-a-a depth++;
    -a-a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a-a depth--;

    -a-a-a-a-a-a-a return 1;
    -a-a-a }

    Here, simulate(P) faithfully simulates the execution of P,
    including the code of HHH itself and its access to the simulated
    state.

    The execution proceeds as follows:

    int HHHH(ptr P);

    int DDDD()
    {
    -a-a int Halt_Status = HHHH(DDDD);
    -a-a if (Halt_Status)
    -a-a-a-a HERE: goto HERE;
    -a-a return Halt_Status;
    }

    int simulateXXX(ptr P)
    {
    -a-a P();
    -a-a return 1;
    }

    int HHHH(ptr P)
    {
    -a-a static int depth = 0;

    -a-a if (depth > 0)
    -a-a-a-a return 0;

    -a-a depth++;
    -a-a simulateXXX(P);
    -a-a depth--;
    -a-a return 1;
    }

    int main()
    {
    -a-a Output("Input_Halts = ", HHHH(DDDD));
    -a-a return 0;
    }

    I can give the the machine code trace.
    It is quite verbose. The simulated DDDD
    never reaches its own simulated return
    and HHHH returns the correct halt status.

    dbush could see that the meaning of these words made them true:

    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    (1) This seems dead obvious to me.
    (2) The above words
    *There does not exist any implementation of C function HHH*
    that dbush composed are better than my own best words.

    Peter,

    THANK YOU.

    You have just provided a concrete C program that REFUTES YOUR OWN CLAIM. >>>
    Let's execute YOUR code.

    Initially:

    -a-a-a depth = 0

    The outer HHHH(DDDD) executes:

    -a-a-a depth++;

    Now:

    -a-a-a depth = 1

    Then:

    -a-a-a simulateXXX(DDDD);

    which executes:

    -a-a-a DDDD();

    Inside DDDD:

    -a-a-a Halt_Status = HHHH(DDDD);

    This nested invocation executes:

    -a-a-a if (depth > 0)
    -a-a-a-a-a-a-a return 0;

    Since depth == 1, HHHH returns 0.

    Back inside DDDD:

    -a-a-a Halt_Status == 0

    Therefore:

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    does NOT enter the loop.

    And the very next statement is:

    -a-a-a return Halt_Status;

    DDDD RETURNS ZERO.

    The outer HHHH then decrements depth and returns 1.

    So YOUR OWN PROGRAM establishes:

    -a-a-a DDDD reaches its return statement.

    -a-a-a HHHH(DDDD) returns 1.

    -a-a-a Both executions terminate.

    -a-a-a The returned halt status is correct.

    And yet you write:

    -a-a-a "The simulated DDDD never reaches
    -a-a-a-a its own simulated return"

    WHAT THE FUCK ARE YOU TALKING ABOUT?

    Your simulateXXX calls DDDD directly rather than interpreting its
    machine instructions. But the actual C execution is perfectly clear.

    YES, PLEASE PROVIDE THE MACHINE CODE TRACE.

    In particular, show us where DDDD supposedly fails to execute its
    return instruction.

    Because according to the C code YOU JUST POSTED, it MUST reach that
    return.

    You have managed to construct a counterexample to your own universal
    claim, POST IT YOURSELF, and then declare that it proves the exact
    opposite.

    That is quite an achievement.

    _HHHH()
    [000021f6] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [000021f7] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [000021f9] 833d0000000000 cmp dword [00000000],+00
    [00002200] 7e04-a-a-a-a-a-a-a-a-a-a jng 00002206
    [00002202] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
    [00002204] eb2d-a-a-a-a-a-a-a-a-a-a jmp 00002233
    [00002206] a100000000-a-a-a-a mov eax,[00000000]
    [0000220b] 83c001-a-a-a-a-a-a-a-a add eax,+01
    [0000220e] a300000000-a-a-a-a mov [00000000],eax
    [00002213] 8b4d08-a-a-a-a-a-a-a-a mov ecx,[ebp+08]
    [00002216] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
    [00002217] e84a000000-a-a-a-a call 00002266
    [0000221c] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [0000221f] 8b1500000000-a-a mov edx,[00000000]
    [00002225] 83ea01-a-a-a-a-a-a-a-a sub edx,+01
    [00002228] 891500000000-a-a mov [00000000],edx
    [0000222e] b801000000-a-a-a-a mov eax,00000001
    [00002233] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002234] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0063) [00002234]

    _DDDD()
    [00002236] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [00002237] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [00002239] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
    [0000223a] 6836220000-a-a-a-a push 00002236
    [0000223f] e8b2ffffff-a-a-a-a call 000021f6
    [00002244] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [00002247] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
    [0000224a] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
    [0000224e] 7402-a-a-a-a-a-a-a-a-a-a jz 00002252
    [00002250] ebfe-a-a-a-a-a-a-a-a-a-a jmp 00002250
    [00002252] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
    [00002255] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
    [00002257] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002258] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0035) [00002258]

    _simulateXXX()
    [00002266] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [00002267] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [00002269] ff5508-a-a-a-a-a-a-a-a call dword [ebp+08]
    [0000226c] b801000000-a-a-a-a mov eax,00000001
    [00002271] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002272] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0013) [00002272]

    _main()
    [00002276] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [00002277] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [00002279] 6836220000-a-a-a-a push 00002236
    [0000227e] e873ffffff-a-a-a-a call 000021f6
    [00002283] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [00002286] 50-a-a-a-a-a-a-a-a-a-a-a-a push eax
    [00002287] 6887070000-a-a-a-a push 00000787
    [0000228c] e815e5ffff-a-a-a-a call 000007a6
    [00002291] 83c408-a-a-a-a-a-a-a-a add esp,+08
    [00002294] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
    [00002296] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002297] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0034) [00002297]





    -a machine-a-a stack-a-a-a-a stack-a-a-a-a machine-a-a-a-a-a-a-a assembly
    -a address-a-a address-a-a data-a-a-a-a-a code-a-a-a-a-a-a-a-a-a-a language >> -a ========-a ========-a ========-a ============== =============
    [00002276][001039d6][00000000] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [00002277][001039d6][00000000] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [00002279][001039d2][00002236] 6836220000-a-a-a-a push 00002236

    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a // call HHH(DDDD)
    [0000227e][001039ce][00002283] e873ffffff-a-a-a-a call 000021f6
    [000021f6][001039ca][001039d6] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [000021f7][001039ca][001039d6] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [000021f9][001039ca][001039d6] 833d0000000000 cmp dword [00000000],+00
    [00002200][001039ca][001039d6] 7e04-a-a-a-a-a-a-a-a-a-a jng 00002206
    [00002202][001039ca][001039d6] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
    [00002204][001039ca][001039d6] eb2d-a-a-a-a-a-a-a-a-a-a jmp 00002233
    [00002233][001039ce][00002283] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002234][001039d2][00002236] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a // end HHHH
    [00002283][001039d6][00000000] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [00002286][001039d2][00000000] 50-a-a-a-a-a-a-a-a-a-a-a-a push eax
    [00002287][001039ce][00000787] 6887070000-a-a-a-a push 00000787
    [0000228c][001039ce][00000787] e815e5ffff-a-a-a-a call 000007a6
    Input_Halts = 0
    [00002291][001039d6][00000000] 83c408-a-a-a-a-a-a-a-a add esp,+08
    [00002294][001039d6][00000000] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
    [00002296][001039da][90909090] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002297][001039de][90909090] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Number of Instructions Executed(19) == 0 Pages

    Peter,

    THANK YOU FOR THE MACHINE CODE TRACE.

    It exposes the problem immediately.

    Look at YOUR trace:

    -a-a 000021f9-a cmp dword [00000000],+00
    -a-a 00002200-a jng 00002206
    -a-a 00002202-a xor eax,eax
    -a-a 00002204-a jmp 00002233

    The conditional jump is NOT taken.

    Therefore, the condition:

    -a-a depth > 0

    is TRUE at the very beginning of the OUTER HHHH invocation.

    BUT YOUR SOURCE CODE DECLARES:

    -a-a static int depth = 0;

    At the start of the program, depth MUST be zero.

    Consequently, the correct execution must take the branch to 00002206, increment depth, and call simulateXXX(DDDD).

    YOUR TRACE DOES NONE OF THAT.

    It immediately returns zero, without ever calling DDDD.

    Indeed, your entire trace contains only 19 executed instructions!

    So when you claim:

    -a-a "The simulated DDDD never reaches
    -a-a-a its own simulated return"

    you are describing a simulation THAT NEVER EVEN STARTED.

    And there is an even more obvious discrepancy.

    Your trace prints:

    -a-a Input_Halts = 0

    But your C program, executed with its correctly initialized static
    variable, prints:

    -a-a Input_Halts = 1

    because DDDD DOES reach its return statement.

    Your trace is therefore NOT a valid execution of the C program you
    presented from its specified initial state.

    The most likely explanation is that your emulator has not correctly initialized the simulated static storage.

    You have confused a BUG IN YOUR SIMULATOR with a mathematical
    impossibility.

    FOR FUCK'S SAKE, PETER.

    Before claiming to have refuted the Halting Theorem, perhaps make sure
    your emulator can correctly execute a static variable initialized to zero.

    Please show the initial contents of the memory location corresponding to depth, and explain why the first conditional jump is not taken.

    That is what your code specifies in my system.
    My HHH creates of whole separate process context
    to simulate DD. DD has its own separate registers,
    stack and local memory. When DD calls HHH(DD) the
    outside HHH simulates itself in this new process
    context.
    --
    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@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 13:51:02 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "My HHH creates a whole separate process context
    to simulate DD."

    AND SO WHAT?

    Creating a separate execution context does not magically abolish the operational semantics of C.

    You now have TWO possibilities.

    CASE 1: A FRESH PROCESS CONTEXT.

    The simulated program starts with its static storage correctly
    initialized.

    Therefore:

    static int depth = 0;

    means depth == 0.

    Your trace, however, takes the branch corresponding to depth > 0.

    WHY?

    CASE 2: AN INVOCATION WITHIN THE EXISTING PROCESS STATE.

    The outer HHHH has already executed:

    depth++;

    Therefore depth == 1 when DDDD invokes HHHH.

    The nested HHHH returns 0.

    DDDD then reaches its return statement.

    END OF STORY.

    You cannot simultaneously claim that the simulated execution has a fresh, independent process state AND that it inherits arbitrary values from the
    outer execution.

    Nor can you silently change the execution context and pretend that you are still simulating the same C execution.

    And there is something even more elementary.

    Your trace never executes:

    call simulateXXX

    or:

    call DDDD

    It establishes NOTHING about whether DDDD can reach its return statement.

    It merely shows that your outer HHHH returns immediately because its
    initial test evaluates depth > 0.

    SO ANSWER THE ACTUAL QUESTION:

    What is the initial value of depth in your simulated process, and WHY?

    If it is zero, your trace is inconsistent with the source code.

    If it is positive, explain precisely how that state was established and
    which execution you are supposedly simulating.

    STOP HIDING BEHIND THE WORD "SIMULATION".

    A faithful simulator must preserve the semantics of the program it
    simulates.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 08:01:33 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 7:51 AM, Python wrote:
    Peter,

    -a-a "My HHH creates a whole separate process context
    -a-a-a to simulate DD."

    AND SO WHAT?


    The means that you code seems to crash the stack.

    Creating a separate execution context does not magically abolish the operational semantics of C.

    You now have TWO possibilities.

    CASE 1: A FRESH PROCESS CONTEXT.

    The simulated program starts with its static storage correctly initialized.

    Therefore:

    -a-a static int depth = 0;

    means depth == 0.

    Your trace, however, takes the branch corresponding to depth > 0.

    WHY?

    CASE 2: AN INVOCATION WITHIN THE EXISTING PROCESS STATE.

    The outer HHHH has already executed:

    -a-a depth++;

    Therefore depth == 1 when DDDD invokes HHHH.

    The nested HHHH returns 0.

    DDDD then reaches its return statement.

    END OF STORY.

    You cannot simultaneously claim that the simulated execution has a
    fresh, independent process state AND that it inherits arbitrary values
    from the outer execution.

    Nor can you silently change the execution context and pretend that you
    are still simulating the same C execution.

    And there is something even more elementary.

    Your trace never executes:

    -a-a call simulateXXX

    or:

    -a-a call DDDD

    It establishes NOTHING about whether DDDD can reach its return statement.

    It merely shows that your outer HHHH returns immediately because its
    initial test evaluates depth > 0.

    SO ANSWER THE ACTUAL QUESTION:

    What is the initial value of depth in your simulated process, and WHY?

    If it is zero, your trace is inconsistent with the source code.

    If it is positive, explain precisely how that state was established and which execution you are supposedly simulating.

    STOP HIDING BEHIND THE WORD "SIMULATION".

    A faithful simulator must preserve the semantics of the program it simulates.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 14:05:01 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "That means that your code seems to crash the stack."

    SEEMS?

    You have the source code. You have the machine code. You have the
    emulator.

    SHOW THE FUCKING STACK OVERFLOW.

    Your previous trace executes exactly 19 instructions.

    It never calls DDDD.

    It never calls simulateXXX.

    It never performs a recursive call.

    THERE IS NO STACK OVERFLOW IN THAT TRACE.

    Now, if your simulator creates a fresh process with depth initialized to
    zero every time it encounters HHHH, you may indeed produce unbounded recursion.

    BUT THAT IS NOT THE EXECUTION I DESCRIBED.

    In my example, the nested HHHH invocation observes depth == 1 and returns
    0. Consequently, DDDD returns normally.

    The crucial question is whether the simulated invocation shares the
    existing program state or starts in a newly initialized state.

    YOU MUST SPECIFY WHICH.

    You cannot change the state semantics halfway through the argument and
    then declare that my counterexample fails.

    And you still haven't answered the simplest question of all:

    WHY DOES YOUR PREVIOUS TRACE TAKE THE depth > 0 BRANCH AT THE VERY FIRST
    HHHH CALL?

    If depth starts at zero, it should not.

    If depth starts above zero, explain why.

    If your emulator crashes the stack in some other execution, provide THAT trace, including the initial state and the sequence of nested calls.

    Until then, "seems to crash the stack" is speculation, not a refutation.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 08:13:56 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 8:05 AM, Python wrote:
    Peter,

    -a-a "That means that your code seems to crash the stack."

    SEEMS?


    I don't care about your code.
    Youu code cannot possibly prove its point.
    Even if your code does prove its point that
    only would show that the dbush words are incorrect.

    You have the source code. You have the machine code. You have the emulator.

    SHOW THE FUCKING STACK OVERFLOW.

    Your previous trace executes exactly 19 instructions.

    It never calls DDDD.

    It never calls simulateXXX.

    It never performs a recursive call.

    THERE IS NO STACK OVERFLOW IN THAT TRACE.

    Now, if your simulator creates a fresh process with depth initialized to zero every time it encounters HHHH, you may indeed produce unbounded recursion.

    BUT THAT IS NOT THE EXECUTION I DESCRIBED.

    In my example, the nested HHHH invocation observes depth == 1 and
    returns 0. Consequently, DDDD returns normally.

    The crucial question is whether the simulated invocation shares the
    existing program state or starts in a newly initialized state.

    YOU MUST SPECIFY WHICH.

    You cannot change the state semantics halfway through the argument and
    then declare that my counterexample fails.

    And you still haven't answered the simplest question of all:

    WHY DOES YOUR PREVIOUS TRACE TAKE THE depth > 0 BRANCH AT THE VERY FIRST HHHH CALL?

    If depth starts at zero, it should not.

    If depth starts above zero, explain why.

    If your emulator crashes the stack in some other execution, provide THAT trace, including the initial state and the sequence of nested calls.

    Until then, "seems to crash the stack" is speculation, not a refutation.
    --
    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,comp.ai.philosophy on Wed Nov 11 08:17:00 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 8:05 AM, Python wrote:
    Peter,

    -a-a "That means that your code seems to crash the stack."

    SEEMS?

    You have the source code. You have the machine code. You have the emulator.



    There does not exist any implementation of C function HHH
    that ONLY simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 14:23:28 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Even if your code does prove its point
    that only would show that the dbush
    words are incorrect."

    EXACTLY!

    THAT IS THE FUCKING POINT!

    You have spent DAYS demanding that I agree with those words.

    I said NO.

    I provided a counterexample.

    And now you acknowledge that, if the counterexample works, THOSE WORDS ARE FALSE.

    PROGRESS AT LAST!

    But apparently you have decided to move the goalposts again.

    Your previous proposition said:

    "any implementation of C function HHH
    that simulates C function DD"

    Your new proposition says:

    "any implementation of C function HHH
    that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    Does it forbid state variables?

    Does it forbid examining the simulated execution?

    Does it forbid returning a result?

    Does it forbid any computation other than interpreting DD's instructions?

    GIVE A PRECISE DEFINITION.

    And explain how this new restriction affects the counterexample.

    You cannot rescue a false universal proposition by repeatedly adding
    undefined restrictions.

    As for your declaration:

    "I don't care about your code."

    Of course you don't.

    Your entire argument depends on the impossibility of a counterexample, and
    you refuse to examine one.

    THAT IS NOT MATHEMATICS, PETER.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 08:29:59 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 8:23 AM, Python wrote:
    Peter,

    -a-a "Even if your code does prove its point
    -a-a-a that only would show that the dbush
    -a-a-a words are incorrect."

    EXACTLY!



    So I add one word. DONE !!!
    There does not exist any implementation of C function HHH
    that [ONLY] simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 14:31:32 2026
    From Newsgroup: comp.ai.philosophy

    Le 11/11/2026 |a 15:30, olcott a |-crit :
    On 11/11/2026 8:23 AM, Python wrote:
    Peter,

    -a-a "Even if your code does prove its point
    -a-a-a that only would show that the dbush
    -a-a-a words are incorrect."

    EXACTLY!



    So I add one word. DONE !!!
    There does not exist any implementation of C function HHH
    that [ONLY] simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    "So I add one word. DONE !!!"

    HAHAHAHA!

    You have just demonstrated your entire approach to mathematical reasoning:

    Counterexample?
    ADD ONE WORD.
    DONE!!!

    Unfortunately, mathematics doesn't work that way.

    What does "ONLY simulates" mean?

    A simulator is itself a program. It executes instructions, maintains
    state, evaluates conditions, and may terminate.

    Does "ONLY" forbid all of that?

    Or does it simply mean:

    "Any implementation except those
    that invalidate my conclusion"?

    Because THAT is not a mathematical definition.

    And even if your new restriction successfully excludes my counterexample,
    it does not establish that your revised proposition is true.

    YOU STILL HAVE TO PROVE IT.

    More importantly, your original proposition was UNIVERSAL.

    You have now admitted that a counterexample could invalidate it, and you
    have CHANGED ITS WORDING to escape that counterexample.

    So much for your supposedly unquestionable "five-way agreement".

    You don't prove theorems by adding words until counterexamples disappear.

    You prove them by stating PRECISE hypotheses and deriving the conclusion.

    ONE WORD ADDED.

    ZERO PROOFS PROVIDED.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 08:46:04 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 8:31 AM, Python wrote:
    Le 11/11/2026 |a 15:30, olcott a |-crit :
    On 11/11/2026 8:23 AM, Python wrote:
    Peter,

    -a-a-a "Even if your code does prove its point
    -a-a-a-a that only would show that the dbush
    -a-a-a-a words are incorrect."

    EXACTLY!



    So I add one word. DONE !!!
    There does not exist any implementation of C function HHH
    that [ONLY] simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a "So I add one word. DONE !!!"

    HAHAHAHA!


    If I don't cut out the inessentials I will be
    dead long before I get my work fully validated
    by human experts.

    99% of my reviewer begin with the axioms that I
    must be wrong and spent 99% of the concentration
    in the attempt to find an error.

    If these same humans would spend 100% of these time
    carefully focusing on understanding the details of
    my proof and these same humans have the mandatory
    prerequisite knowledge It would take less than two
    hours to totally validate my current proof with each
    human expert.

    The mandatory prerequisite knowledge is an expert
    in C, high intelligence to understand complex
    reasoning.

    No knowledge of the halting problem is required.
    If there is knowledge of the halting problem then
    this must be accompanied with deep knowledge of
    theoretical foundations 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 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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 14:55:29 2026
    From Newsgroup: comp.ai.philosophy

    Le 11/11/2026 |a 15:46, olcott a |-crit :
    On 11/11/2026 8:31 AM, Python wrote:
    Le 11/11/2026 |a 15:30, olcott a |-crit :
    On 11/11/2026 8:23 AM, Python wrote:
    Peter,

    -a-a-a "Even if your code does prove its point
    -a-a-a-a that only would show that the dbush
    -a-a-a-a words are incorrect."

    EXACTLY!



    So I add one word. DONE !!!
    There does not exist any implementation of C function HHH
    that [ONLY] simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a "So I add one word. DONE !!!"

    HAHAHAHA!


    If I don't cut out the inessentials I will be
    dead long before I get my work fully validated
    by human experts.

    99% of my reviewer begin with the axioms that I
    must be wrong and spent 99% of the concentration
    in the attempt to find an error.

    If these same humans would spend 100% of these time
    carefully focusing on understanding the details of
    my proof and these same humans have the mandatory
    prerequisite knowledge It would take less than two
    hours to totally validate my current proof with each
    human expert.

    The mandatory prerequisite knowledge is an expert
    in C, high intelligence to understand complex
    reasoning.

    No knowledge of the halting problem is required.
    If there is knowledge of the halting problem then
    this must be accompanied with deep knowledge of
    theoretical foundations of computation.

    Peter,

    Your requirements for reviewing your "proof" are becoming RIDICULOUSLY PEDANTIC.

    Apparently, a qualified reviewer must:

    - Be an expert in C.
    - Possess sufficiently high intelligence.
    - Understand the foundations of computation, but preferably not know too
    much about the Halting Problem.
    - Concentrate exclusively on understanding your proof rather than looking
    for errors.
    - Validate everything in less than two hours.

    FOR FUCK'S SAKE!

    A mathematical proof is not validated by finding someone sufficiently intelligent to AGREE WITH YOU.

    It is validated by surviving rigorous scrutiny.

    LOOKING FOR ERRORS IS PRECISELY WHAT A COMPETENT REVIEWER IS SUPPOSED TO
    DO.

    And when someone produces a counterexample, the appropriate response is
    not:

    "I don't care about your code."

    or:

    "So I add one word. DONE !!!"

    You have spent days arguing over the wording of a single sentence,
    repeatedly changing its meaning, while refusing to address the technical objections.

    You don't need more intelligent reviewers, Peter.

    You need a precise statement, a valid proof, and the willingness to
    examine counterexamples.

    And no, adding "ONLY" is not a substitute for any of those.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 09:13:51 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 8:55 AM, Python wrote:
    Le 11/11/2026 |a 15:46, olcott a |-crit :
    On 11/11/2026 8:31 AM, Python wrote:
    Le 11/11/2026 |a 15:30, olcott a |-crit :
    On 11/11/2026 8:23 AM, Python wrote:
    Peter,

    -a-a-a "Even if your code does prove its point
    -a-a-a-a that only would show that the dbush
    -a-a-a-a words are incorrect."

    EXACTLY!



    So I add one word. DONE !!!
    There does not exist any implementation of C function HHH
    that [ONLY] simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    -a-a-a "So I add one word. DONE !!!"

    HAHAHAHA!


    If I don't cut out the inessentials I will be
    dead long before I get my work fully validated
    by human experts.

    99% of my reviewer begin with the axioms that I
    must be wrong and spent 99% of the concentration
    in the attempt to find an error.

    If these same humans would spend 100% of these time
    carefully focusing on understanding the details of
    my proof and these same humans have the mandatory
    prerequisite knowledge It would take less than two
    hours to totally validate my current proof with each
    human expert.

    The mandatory prerequisite knowledge is an expert
    in C, high intelligence to understand complex
    reasoning.

    No knowledge of the halting problem is required.
    If there is knowledge of the halting problem then
    this must be accompanied with deep knowledge of
    theoretical foundations of computation.

    Peter,

    Your requirements for reviewing your "proof" are becoming RIDICULOUSLY PEDANTIC.

    Apparently, a qualified reviewer must:

    - Be an expert in C.
    - Possess sufficiently high intelligence.
    - Understand the foundations of computation, but preferably not know too much about the Halting Problem.
    - Concentrate exclusively on understanding your proof rather than
    looking for errors.
    - Validate everything in less than two hours.


    Very terribly bad paraphrase.
    Any knowledge of the halting problem must
    come with expert knowledge of the foundation
    of computation.

    FOR FUCK'S SAKE!

    A mathematical proof is not validated by finding someone sufficiently intelligent to AGREE WITH YOU.

    It is validated by surviving rigorous scrutiny.

    LOOKING FOR ERRORS IS PRECISELY WHAT A COMPETENT REVIEWER IS SUPPOSED TO
    DO.

    And when someone produces a counterexample, the appropriate response is
    not:

    -a-a "I don't care about your code."

    or:

    -a-a "So I add one word. DONE !!!"

    You have spent days arguing over the wording of a single sentence, repeatedly changing its meaning, while refusing to address the technical objections.

    You don't need more intelligent reviewers, Peter.

    You need a precise statement, a valid proof, and the willingness to
    examine counterexamples.

    And no, adding "ONLY" is not a substitute for any of those.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 15:15:57 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Very terribly bad paraphrase."

    Fine. Let me correct it.

    You require reviewers who know the Halting Problem to ALSO have expert knowledge of the foundations of computation.

    Fair enough.

    NOW WHAT?

    Does that make your proof correct?

    Does it explain what "ONLY simulates" means?

    Does it answer the counterexample?

    Does it explain your machine-code trace?

    NO.

    You have devoted more attention to correcting a minor paraphrase of your reviewer requirements than to addressing the actual mathematical
    objections.

    And there is something particularly amusing about your complaint.

    You demand reviewers who spend 100% of their attention UNDERSTANDING your proof rather than LOOKING FOR ERRORS.

    PETER, LOOKING FOR ERRORS IS HOW PROOFS ARE VERIFIED.

    A reviewer who merely tries to understand your intended reasoning without testing its validity is not validating anything.

    So enough about the qualifications of your imaginary ideal reviewers.

    DEFINE "ONLY SIMULATES".

    STATE YOUR PRECISE CLAIM.

    PROVE IT.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 08:30:15 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a "any implementation of C function HHH
    -a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a "any implementation of C function HHH
    -a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to testing for non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt
    decider') then yes, HHH(DD) would be stuck in a pattern of infinite
    recursion, but then it also wouldn't be the HHH which he claims to be a potential halt decider, so the argument falls apart.

    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 comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 09:34:07 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 9:15 AM, Python wrote:
    Peter,

    -a-a "Very terribly bad paraphrase."

    Fine. Let me correct it.

    You require reviewers who know the Halting Problem to ALSO have expert knowledge of the foundations of computation.

    Fair enough.

    NOW WHAT?

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 15:45:21 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct?

    That a reviewer might understand the Halting Problem, possess the
    necessary expertise, pay close attention, engage honestly, stay strictly
    on topic...

    ..and STILL conclude that your argument is wrong?

    Because if you define an "honest reviewer" as someone who eventually
    agrees with you, you're not asking for independent verification.

    You're asking for confirmation.

    And that's not how mathematical proofs work.

    A proof must withstand criticism, not require agreement as a condition of honest dialogue.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 10:29:41 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to testing for non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt
    decider') then yes, HHH(DD) would be stuck in a pattern of infinite recursion, but then it also wouldn't be the HHH which he claims to be a potential halt decider, so the argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

    <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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.
    --
    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,comp.ai.philosophy on Wed Nov 11 10:34:20 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.
    --
    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 09:59:54 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to testing for
    non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt
    decider') then yes, HHH(DD) would be stuck in a pattern of infinite
    recursion, but then it also wouldn't be the HHH which he claims to be
    a potential halt decider, so the argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY in your
    new formulation. I'd offered my interpretation, but you neither confirm
    nor deny it. How does repeating three things verbatim from your previous
    posts offer any sort of clarification?

    Communication is not your strong point. Maybe try working on that by
    actually providing the requested clarification. What does the word ONLY achieve in your new formulation?

    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 comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 11:23:59 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to testing
    for non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt
    decider') then yes, HHH(DD) would be stuck in a pattern of infinite
    recursion, but then it also wouldn't be the HHH which he claims to be
    a potential halt decider, so the argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY in your
    new formulation. I'd offered my interpretation, but you neither confirm
    nor deny it. How does repeating three things verbatim from your previous posts offer any sort of clarification?

    Communication is not your strong point. Maybe try working on that by actually providing the requested clarification. What does the word ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.
    --
    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 Mike Terry@news.dead.person.stones@darjeeling.plus.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 17:36:50 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 13:30, Python wrote:
    Le 11/11/2026 a 14:23, olcott a ocrit :
    On 11/11/2026 6:23 AM, Python wrote:
    Le 11/11/2026 a 05:41, olcott a ocrit :
    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 a 17:16, Python a ocrit :
    Le 10/11/2026 a 17:15, olcott a ocrit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 a 15:57, olcott a ocrit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 a 02:02, olcott a ocrit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 a 19:18, olcott a ocrit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    aaa "simulated D would never stop running
    aaaa unless [simulation is] aborted"

    becomes:

    aaa "simulated D would never stop running
    aaaa while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted] >>>>>>>>>>>>> aaaa is translated into
    aaaa "simulated D would never stop running while being simulated" >>>>>>>>>>>>> aaaa [would never stop running]
    aaaa is translated into
    aaaa never halts

    aaaa [simulated D would never stop running unless aborted] >>>>>>>>>>>>> aaaa becomes
    aaaa "simulated D would never halt while being simulated" >>>>>>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    aaaa > WHILE THE SIMULATION CONTINUES,
    aaaa > DD DOES NOT REACH ITS RETURN.
    aaaa >
    aaaa [REACH ITS RETURN]
    aaaa is translated into
    aaaa HALT

    aaaa On 11/2/2026 8:50 AM, Python wrote:
    aaaa > WHILE THE SIMULATION CONTINUES,
    aaaa > DD DOES NOT REACH ITS RETURN.
    aaaa >
    aaaa is translated into
    aaaa WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>>
    (1) "simulated D would never halt while being simulated" >>>>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT

    Peter,

    FINALLY, you have written two statements that can be compared directly.

    aaa (1) Simulated D would never halt
    aaaaaaa while being simulated.

    aaa (2) WHILE THE SIMULATION CONTINUES,
    aaaaaaa DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition. >>>>>>>>>>>>
    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    aaa "Show how they can express different propositions."

    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches >>>>>>>>> its own simulated return statement in any N finite number of >>>>>>>>> steps.

    Peter,

    aaa "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement".

    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU DISHONESTLY PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a much stronger proposition that
    I NEVER agreed to.

    Your alleged agreement now contains:

    aaa "There does not exist ANY implementation..."

    aaa "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION CONTINUES.

    You have transformed that into a universal claim about EVERY possible implementation of HHH
    and EVERY finite number of steps.

    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT FOR DAYS. >>>>>>>>
    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE. >>>>>>>>
    You reject it because it does not satisfy the stronger proposition whose derivation is
    precisely what is being challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition instead of dishonestly
    pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD, but whose simulated invocation
    of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    aaa int Halt_Status = HHH(DD);

    aaa if (Halt_Status)
    aaaaaaa HERE: goto HERE;

    aaa return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify PRECISELY what additional
    constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict that quantification whenever
    someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH invoked by the simulated DD
    must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like pseudocode: >>>>>
    aaa int HHH(ptr P)
    aaa {
    aaaaaaa static int depth = 0;

    aaaaaaa if (depth > 0)
    aaaaaaaaaaa return 0;

    aaaaaaa depth++;
    aaaaaaa simulate(P);
    aaaaaaa depth--;

    aaaaaaa return 1;
    aaa }

    Here, simulate(P) faithfully simulates the execution of P, including the code of HHH itself and
    its access to the simulated state.

    The execution proceeds as follows:

    int HHHH(ptr P);

    int DDDD()
    {
    aa int Halt_Status = HHHH(DDDD);
    aa if (Halt_Status)
    aaaa HERE: goto HERE;
    aa return Halt_Status;
    }

    int simulateXXX(ptr P)
    {
    aa P();
    aa return 1;
    }

    int HHHH(ptr P)
    {
    aa static int depth = 0;

    aa if (depth > 0)
    aaaa return 0;

    aa depth++;
    aa simulateXXX(P);
    aa depth--;
    aa return 1;
    }

    int main()
    {
    aa Output("Input_Halts = ", HHHH(DDDD));
    aa return 0;
    }

    I can give the the machine code trace.
    It is quite verbose. The simulated DDDD
    never reaches its own simulated return
    and HHHH returns the correct halt status.

    dbush could see that the meaning of these words made them true:

    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    (1) This seems dead obvious to me.
    (2) The above words
    *There does not exist any implementation of C function HHH*
    that dbush composed are better than my own best words.

    Peter,

    THANK YOU.

    You have just provided a concrete C program that REFUTES YOUR OWN CLAIM. >>>
    Let's execute YOUR code.

    Initially:

    aaa depth = 0

    The outer HHHH(DDDD) executes:

    aaa depth++;

    Now:

    aaa depth = 1

    Then:

    aaa simulateXXX(DDDD);

    which executes:

    aaa DDDD();

    Inside DDDD:

    aaa Halt_Status = HHHH(DDDD);

    This nested invocation executes:

    aaa if (depth > 0)
    aaaaaaa return 0;

    Since depth == 1, HHHH returns 0.

    Back inside DDDD:

    aaa Halt_Status == 0

    Therefore:

    aaa if (Halt_Status)
    aaaaaaa HERE: goto HERE;

    does NOT enter the loop.

    And the very next statement is:

    aaa return Halt_Status;

    DDDD RETURNS ZERO.

    The outer HHHH then decrements depth and returns 1.

    So YOUR OWN PROGRAM establishes:

    aaa DDDD reaches its return statement.

    aaa HHHH(DDDD) returns 1.

    aaa Both executions terminate.

    aaa The returned halt status is correct.

    And yet you write:

    aaa "The simulated DDDD never reaches
    aaaa its own simulated return"

    WHAT THE FUCK ARE YOU TALKING ABOUT?

    Your simulateXXX calls DDDD directly rather than interpreting its machine instructions. But the
    actual C execution is perfectly clear.

    YES, PLEASE PROVIDE THE MACHINE CODE TRACE.

    In particular, show us where DDDD supposedly fails to execute its return instruction.

    Because according to the C code YOU JUST POSTED, it MUST reach that return. >>>
    You have managed to construct a counterexample to your own universal claim, POST IT YOURSELF, and
    then declare that it proves the exact opposite.

    That is quite an achievement.

    _HHHH()
    [000021f6] 55aaaaaaaaaaaa push ebp
    [000021f7] 8becaaaaaaaaaa mov ebp,esp
    [000021f9] 833d0000000000 cmp dword [00000000],+00
    [00002200] 7e04aaaaaaaaaa jng 00002206
    [00002202] 33c0aaaaaaaaaa xor eax,eax
    [00002204] eb2daaaaaaaaaa jmp 00002233
    [00002206] a100000000aaaa mov eax,[00000000]
    [0000220b] 83c001aaaaaaaa add eax,+01
    [0000220e] a300000000aaaa mov [00000000],eax
    [00002213] 8b4d08aaaaaaaa mov ecx,[ebp+08]
    [00002216] 51aaaaaaaaaaaa push ecx
    [00002217] e84a000000aaaa call 00002266
    [0000221c] 83c404aaaaaaaa add esp,+04
    [0000221f] 8b1500000000aa mov edx,[00000000]
    [00002225] 83ea01aaaaaaaa sub edx,+01
    [00002228] 891500000000aa mov [00000000],edx
    [0000222e] b801000000aaaa mov eax,00000001
    [00002233] 5daaaaaaaaaaaa pop ebp
    [00002234] c3aaaaaaaaaaaa ret
    Size in bytes:(0063) [00002234]

    _DDDD()
    [00002236] 55aaaaaaaaaaaa push ebp
    [00002237] 8becaaaaaaaaaa mov ebp,esp
    [00002239] 51aaaaaaaaaaaa push ecx
    [0000223a] 6836220000aaaa push 00002236
    [0000223f] e8b2ffffffaaaa call 000021f6
    [00002244] 83c404aaaaaaaa add esp,+04
    [00002247] 8945fcaaaaaaaa mov [ebp-04],eax
    [0000224a] 837dfc00aaaaaa cmp dword [ebp-04],+00
    [0000224e] 7402aaaaaaaaaa jz 00002252
    [00002250] ebfeaaaaaaaaaa jmp 00002250
    [00002252] 8b45fcaaaaaaaa mov eax,[ebp-04]
    [00002255] 8be5aaaaaaaaaa mov esp,ebp
    [00002257] 5daaaaaaaaaaaa pop ebp
    [00002258] c3aaaaaaaaaaaa ret
    Size in bytes:(0035) [00002258]

    _simulateXXX()
    [00002266] 55aaaaaaaaaaaa push ebp
    [00002267] 8becaaaaaaaaaa mov ebp,esp
    [00002269] ff5508aaaaaaaa call dword [ebp+08]
    [0000226c] b801000000aaaa mov eax,00000001
    [00002271] 5daaaaaaaaaaaa pop ebp
    [00002272] c3aaaaaaaaaaaa ret
    Size in bytes:(0013) [00002272]

    _main()
    [00002276] 55aaaaaaaaaaaa push ebp
    [00002277] 8becaaaaaaaaaa mov ebp,esp
    [00002279] 6836220000aaaa push 00002236
    [0000227e] e873ffffffaaaa call 000021f6
    [00002283] 83c404aaaaaaaa add esp,+04
    [00002286] 50aaaaaaaaaaaa push eax
    [00002287] 6887070000aaaa push 00000787
    [0000228c] e815e5ffffaaaa call 000007a6
    [00002291] 83c408aaaaaaaa add esp,+08
    [00002294] 33c0aaaaaaaaaa xor eax,eax
    [00002296] 5daaaaaaaaaaaa pop ebp
    [00002297] c3aaaaaaaaaaaa ret
    Size in bytes:(0034) [00002297]





    a machineaa stackaaaa stackaaaa machineaaaaaaa assembly
    a addressaa addressaa dataaaaaa codeaaaaaaaaaa language
    a ========a ========a ========a ============== =============
    [00002276][001039d6][00000000] 55aaaaaaaaaaaa push ebp
    [00002277][001039d6][00000000] 8becaaaaaaaaaa mov ebp,esp
    [00002279][001039d2][00002236] 6836220000aaaa push 00002236

    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa // call HHH(DDDD)
    [0000227e][001039ce][00002283] e873ffffffaaaa call 000021f6
    [000021f6][001039ca][001039d6] 55aaaaaaaaaaaa push ebp
    [000021f7][001039ca][001039d6] 8becaaaaaaaaaa mov ebp,esp
    [000021f9][001039ca][001039d6] 833d0000000000 cmp dword [00000000],+00
    [00002200][001039ca][001039d6] 7e04aaaaaaaaaa jng 00002206
    [00002202][001039ca][001039d6] 33c0aaaaaaaaaa xor eax,eax
    [00002204][001039ca][001039d6] eb2daaaaaaaaaa jmp 00002233
    [00002233][001039ce][00002283] 5daaaaaaaaaaaa pop ebp
    [00002234][001039d2][00002236] c3aaaaaaaaaaaa ret
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa // end HHHH
    [00002283][001039d6][00000000] 83c404aaaaaaaa add esp,+04
    [00002286][001039d2][00000000] 50aaaaaaaaaaaa push eax
    [00002287][001039ce][00000787] 6887070000aaaa push 00000787
    [0000228c][001039ce][00000787] e815e5ffffaaaa call 000007a6
    Input_Halts = 0
    [00002291][001039d6][00000000] 83c408aaaaaaaa add esp,+08
    [00002294][001039d6][00000000] 33c0aaaaaaaaaa xor eax,eax
    [00002296][001039da][90909090] 5daaaaaaaaaaaa pop ebp
    [00002297][001039de][90909090] c3aaaaaaaaaaaa ret
    Number of Instructions Executed(19) == 0 Pages

    Peter,

    THANK YOU FOR THE MACHINE CODE TRACE.

    It exposes the problem immediately.

    Look at YOUR trace:

    aa 000021f9a cmp dword [00000000],+00
    aa 00002200a jng 00002206
    aa 00002202a xor eax,eax
    aa 00002204a jmp 00002233

    The conditional jump is NOT taken.

    Therefore, the condition:

    aa depth > 0

    is TRUE at the very beginning of the OUTER HHHH invocation.

    BUT YOUR SOURCE CODE DECLARES:

    aa static int depth = 0;

    At the start of the program, depth MUST be zero.

    Consequently, the correct execution must take the branch to 00002206, increment depth, and call
    simulateXXX(DDDD).

    Yeah, this is the problem in PO's x86utm that I mentioned in response to your previous
    counter-example code: it does not bother to support the BSS segment. Because you have initialised
    depth to zero, the compiler assigns it to the BSS segment (which contains zeroed storage), but PO
    never maps that to anything. Hence its assignment to virtual address 00000000 in the trace. I also
    mentioned the x86utm bug where PO only process relocations in the code segment, although that does
    not impact your code here. Looks like PO didn't see my comments and rush to fix his code!

    If PO fixed x86utm it would behave as you've described. An alternative bypass would be for you to
    initialise depth to 1, so the compiler will map it to the DATA segment rather than BSS. (x86utm
    handles the DATA segment.) Then in HHHH you could test "if (depth > 1)" instead of "if (depth > 0)".


    Mike.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 12:05:48 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 11:36 AM, Mike Terry wrote:
    On 11/11/2026 13:30, Python wrote:
    Le 11/11/2026 |a 14:23, olcott a |-crit :
    On 11/11/2026 6:23 AM, Python wrote:
    Le 11/11/2026 |a 05:41, olcott a |-crit :
    On 11/10/2026 10:17 AM, Python wrote:
    Le 10/11/2026 |a 17:16, Python a |-crit :
    Le 10/11/2026 |a 17:15, olcott a |-crit :
    On 11/10/2026 9:38 AM, Python wrote:
    Le 10/11/2026 |a 15:57, olcott a |-crit :
    On 11/10/2026 4:50 AM, Python wrote:
    Le 10/11/2026 |a 02:02, olcott a |-crit :
    On 11/9/2026 3:29 PM, Python wrote:
    Le 09/11/2026 |a 19:18, olcott a |-crit :
    On 11/9/2026 9:40 AM, Python wrote:
    Peter,

    -a-a-a "simulated D would never stop running
    -a-a-a-a unless [simulation is] aborted"

    becomes:

    -a-a-a "simulated D would never stop running
    -a-a-a-a while being simulated"

    FINE.

    And now?


    (1) [simulated D would never stop running unless aborted] >>>>>>>>>>>>>> -a-a-a-a is translated into
    -a-a-a-a "simulated D would never stop running while being >>>>>>>>>>>>>> simulated"
    -a-a-a-a [would never stop running]
    -a-a-a-a is translated into
    -a-a-a-a never halts

    -a-a-a-a [simulated D would never stop running unless aborted] >>>>>>>>>>>>>> -a-a-a-a becomes
    -a-a-a-a "simulated D would never halt while being simulated" >>>>>>>>>>>>>>
    (2) On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a [REACH ITS RETURN]
    -a-a-a-a is translated into
    -a-a-a-a HALT

    -a-a-a-a On 11/2/2026 8:50 AM, Python wrote:
    -a-a-a-a > WHILE THE SIMULATION CONTINUES,
    -a-a-a-a > DD DOES NOT REACH ITS RETURN.
    -a-a-a-a >
    -a-a-a-a is translated into
    -a-a-a-a WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>>>
    (1) "simulated D would never halt while being simulated" >>>>>>>>>>>>>> (2) WHILE THE SIMULATION CONTINUES DD DOES NOT HALT >>>>>>>>>>>>>
    Peter,

    FINALLY, you have written two statements that can be >>>>>>>>>>>>> compared directly.

    -a-a-a (1) Simulated D would never halt
    -a-a-a-a-a-a-a while being simulated.

    -a-a-a (2) WHILE THE SIMULATION CONTINUES,
    -a-a-a-a-a-a-a DD DOES NOT HALT.

    As English sentences, these CAN express the same proposition. >>>>>>>>>>>>>
    Show how they can express different propositions.
    Otherwise acknowledge that they cannot express
    different propositions.

    Peter,

    -a-a-a "Show how they can express different propositions." >>>>>>>>>>>
    I ALREADY FUCKING DID.

    Consider a program D that halts after 1,000 steps.

    Simulate D for 100 steps, then abort the simulation.


    That does not meet either one

    *This is the five way agreement* (Sunday November 1)
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches >>>>>>>>>> its own simulated return statement in any N finite number of >>>>>>>>>> steps.

    Peter,

    -a-a-a "That does not meet either one."

    Of course it doesn't meet your alleged "five-way agreement". >>>>>>>>>
    BECAUSE THE FIVE-WAY AGREEMENT IS NOT ABOUT WHAT YOU
    DISHONESTLY PRETEND IT IS. :-)

    You have once again replaced what I ACTUALLY agreed to with a >>>>>>>>> much stronger proposition that I NEVER agreed to.

    Your alleged agreement now contains:

    -a-a-a "There does not exist ANY implementation..."

    -a-a-a "... in ANY N finite number of steps."

    WHERE THE FUCK DID I AGREE TO THAT?

    I agreed that DD does not reach its return WHILE THE SIMULATION >>>>>>>>> CONTINUES.

    You have transformed that into a universal claim about EVERY >>>>>>>>> possible implementation of HHH and EVERY finite number of steps. >>>>>>>>>
    THAT IS PRECISELY THE FALSIFICATION I HAVE BEEN POINTING OUT >>>>>>>>> FOR DAYS.

    And your counterexample objection is ridiculous.

    I provided a counterexample to YOUR CLAIMED LOGICAL EQUIVALENCE. >>>>>>>>>
    You reject it because it does not satisfy the stronger
    proposition whose derivation is precisely what is being
    challenged.

    CIRCULAR REASONING, AGAIN.

    Your alleged five-way agreement is not a proof.

    Your misrepresentation of my words is not a proof.

    And repeating both for another five years won't produce one.

    Do you agree with this?
    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    Peter,

    NO.

    And FINALLY, you are asking whether I agree with this proposition >>>>>>> instead of dishonestly pretending that I already agreed to it.

    Your claim quantifies over ANY implementation of HHH.

    Consider an implementation of HHH that correctly simulates DD,
    but whose simulated invocation of HHH returns 0.

    According to the operational semantics of C, DD then executes:

    -a-a-a int Halt_Status = HHH(DD);

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    -a-a-a return Halt_Status;

    HHH returns 0.

    The conditional branch is not taken.

    DD reaches its return.

    END OF FUCKING STORY.

    If you want to exclude such an implementation, you must specify >>>>>>> PRECISELY what additional constraints you impose on HHH.

    And then prove your proposition under those constraints.

    You cannot quantify over ANY implementation and silently restrict >>>>>>> that quantification whenever someone provides a counterexample.

    So, once again:

    NO, I DO NOT AGREE WITH YOUR PROPOSITION.

    And I NEVER DID.


    A technical clarification concerning my previous message.

    You might object that the HHH executing the simulation and the HHH >>>>>> invoked by the simulated DD must be the SAME implementation.

    FINE.

    Consider the following implementation, expressed in C-like
    pseudocode:

    -a-a-a int HHH(ptr P)
    -a-a-a {
    -a-a-a-a-a-a-a static int depth = 0;

    -a-a-a-a-a-a-a if (depth > 0)
    -a-a-a-a-a-a-a-a-a-a-a return 0;

    -a-a-a-a-a-a-a depth++;
    -a-a-a-a-a-a-a simulate(P);
    -a-a-a-a-a-a-a depth--;

    -a-a-a-a-a-a-a return 1;
    -a-a-a }

    Here, simulate(P) faithfully simulates the execution of P,
    including the code of HHH itself and its access to the simulated
    state.

    The execution proceeds as follows:

    int HHHH(ptr P);

    int DDDD()
    {
    -a-a int Halt_Status = HHHH(DDDD);
    -a-a if (Halt_Status)
    -a-a-a-a HERE: goto HERE;
    -a-a return Halt_Status;
    }

    int simulateXXX(ptr P)
    {
    -a-a P();
    -a-a return 1;
    }

    int HHHH(ptr P)
    {
    -a-a static int depth = 0;

    -a-a if (depth > 0)
    -a-a-a-a return 0;

    -a-a depth++;
    -a-a simulateXXX(P);
    -a-a depth--;
    -a-a return 1;
    }

    int main()
    {
    -a-a Output("Input_Halts = ", HHHH(DDDD));
    -a-a return 0;
    }

    I can give the the machine code trace.
    It is quite verbose. The simulated DDDD
    never reaches its own simulated return
    and HHHH returns the correct halt status.

    dbush could see that the meaning of these words made them true:

    There does not exist any implementation of C function HHH
    that simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps.

    (1) This seems dead obvious to me.
    (2) The above words
    *There does not exist any implementation of C function HHH*
    that dbush composed are better than my own best words.

    Peter,

    THANK YOU.

    You have just provided a concrete C program that REFUTES YOUR OWN
    CLAIM.

    Let's execute YOUR code.

    Initially:

    -a-a-a depth = 0

    The outer HHHH(DDDD) executes:

    -a-a-a depth++;

    Now:

    -a-a-a depth = 1

    Then:

    -a-a-a simulateXXX(DDDD);

    which executes:

    -a-a-a DDDD();

    Inside DDDD:

    -a-a-a Halt_Status = HHHH(DDDD);

    This nested invocation executes:

    -a-a-a if (depth > 0)
    -a-a-a-a-a-a-a return 0;

    Since depth == 1, HHHH returns 0.

    Back inside DDDD:

    -a-a-a Halt_Status == 0

    Therefore:

    -a-a-a if (Halt_Status)
    -a-a-a-a-a-a-a HERE: goto HERE;

    does NOT enter the loop.

    And the very next statement is:

    -a-a-a return Halt_Status;

    DDDD RETURNS ZERO.

    The outer HHHH then decrements depth and returns 1.

    So YOUR OWN PROGRAM establishes:

    -a-a-a DDDD reaches its return statement.

    -a-a-a HHHH(DDDD) returns 1.

    -a-a-a Both executions terminate.

    -a-a-a The returned halt status is correct.

    And yet you write:

    -a-a-a "The simulated DDDD never reaches
    -a-a-a-a its own simulated return"

    WHAT THE FUCK ARE YOU TALKING ABOUT?

    Your simulateXXX calls DDDD directly rather than interpreting its
    machine instructions. But the actual C execution is perfectly clear.

    YES, PLEASE PROVIDE THE MACHINE CODE TRACE.

    In particular, show us where DDDD supposedly fails to execute its
    return instruction.

    Because according to the C code YOU JUST POSTED, it MUST reach that
    return.

    You have managed to construct a counterexample to your own universal
    claim, POST IT YOURSELF, and then declare that it proves the exact
    opposite.

    That is quite an achievement.

    _HHHH()
    [000021f6] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [000021f7] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [000021f9] 833d0000000000 cmp dword [00000000],+00
    [00002200] 7e04-a-a-a-a-a-a-a-a-a-a jng 00002206
    [00002202] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
    [00002204] eb2d-a-a-a-a-a-a-a-a-a-a jmp 00002233
    [00002206] a100000000-a-a-a-a mov eax,[00000000]
    [0000220b] 83c001-a-a-a-a-a-a-a-a add eax,+01
    [0000220e] a300000000-a-a-a-a mov [00000000],eax
    [00002213] 8b4d08-a-a-a-a-a-a-a-a mov ecx,[ebp+08]
    [00002216] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
    [00002217] e84a000000-a-a-a-a call 00002266
    [0000221c] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [0000221f] 8b1500000000-a-a mov edx,[00000000]
    [00002225] 83ea01-a-a-a-a-a-a-a-a sub edx,+01
    [00002228] 891500000000-a-a mov [00000000],edx
    [0000222e] b801000000-a-a-a-a mov eax,00000001
    [00002233] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002234] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0063) [00002234]

    _DDDD()
    [00002236] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [00002237] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [00002239] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
    [0000223a] 6836220000-a-a-a-a push 00002236
    [0000223f] e8b2ffffff-a-a-a-a call 000021f6
    [00002244] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [00002247] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
    [0000224a] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
    [0000224e] 7402-a-a-a-a-a-a-a-a-a-a jz 00002252
    [00002250] ebfe-a-a-a-a-a-a-a-a-a-a jmp 00002250
    [00002252] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
    [00002255] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
    [00002257] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002258] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0035) [00002258]

    _simulateXXX()
    [00002266] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [00002267] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [00002269] ff5508-a-a-a-a-a-a-a-a call dword [ebp+08]
    [0000226c] b801000000-a-a-a-a mov eax,00000001
    [00002271] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002272] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0013) [00002272]

    _main()
    [00002276] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [00002277] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [00002279] 6836220000-a-a-a-a push 00002236
    [0000227e] e873ffffff-a-a-a-a call 000021f6
    [00002283] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [00002286] 50-a-a-a-a-a-a-a-a-a-a-a-a push eax
    [00002287] 6887070000-a-a-a-a push 00000787
    [0000228c] e815e5ffff-a-a-a-a call 000007a6
    [00002291] 83c408-a-a-a-a-a-a-a-a add esp,+08
    [00002294] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
    [00002296] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002297] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Size in bytes:(0034) [00002297]





    -a machine-a-a stack-a-a-a-a stack-a-a-a-a machine-a-a-a-a-a-a-a assembly >>> -a address-a-a address-a-a data-a-a-a-a-a code-a-a-a-a-a-a-a-a-a-a language >>> -a ========-a ========-a ========-a ============== =============
    [00002276][001039d6][00000000] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [00002277][001039d6][00000000] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [00002279][001039d2][00002236] 6836220000-a-a-a-a push 00002236

    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a // call HHH(DDDD)
    [0000227e][001039ce][00002283] e873ffffff-a-a-a-a call 000021f6
    [000021f6][001039ca][001039d6] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
    [000021f7][001039ca][001039d6] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
    [000021f9][001039ca][001039d6] 833d0000000000 cmp dword [00000000],+00
    [00002200][001039ca][001039d6] 7e04-a-a-a-a-a-a-a-a-a-a jng 00002206
    [00002202][001039ca][001039d6] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
    [00002204][001039ca][001039d6] eb2d-a-a-a-a-a-a-a-a-a-a jmp 00002233
    [00002233][001039ce][00002283] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002234][001039d2][00002236] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a // end HHHH
    [00002283][001039d6][00000000] 83c404-a-a-a-a-a-a-a-a add esp,+04
    [00002286][001039d2][00000000] 50-a-a-a-a-a-a-a-a-a-a-a-a push eax
    [00002287][001039ce][00000787] 6887070000-a-a-a-a push 00000787
    [0000228c][001039ce][00000787] e815e5ffff-a-a-a-a call 000007a6
    Input_Halts = 0
    [00002291][001039d6][00000000] 83c408-a-a-a-a-a-a-a-a add esp,+08
    [00002294][001039d6][00000000] 33c0-a-a-a-a-a-a-a-a-a-a xor eax,eax
    [00002296][001039da][90909090] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
    [00002297][001039de][90909090] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
    Number of Instructions Executed(19) == 0 Pages

    Peter,

    THANK YOU FOR THE MACHINE CODE TRACE.

    It exposes the problem immediately.

    Look at YOUR trace:

    -a-a-a 000021f9-a cmp dword [00000000],+00
    -a-a-a 00002200-a jng 00002206
    -a-a-a 00002202-a xor eax,eax
    -a-a-a 00002204-a jmp 00002233

    The conditional jump is NOT taken.

    Therefore, the condition:

    -a-a-a depth > 0

    is TRUE at the very beginning of the OUTER HHHH invocation.

    BUT YOUR SOURCE CODE DECLARES:

    -a-a-a static int depth = 0;

    At the start of the program, depth MUST be zero.

    Consequently, the correct execution must take the branch to 00002206,
    increment depth, and call simulateXXX(DDDD).

    Yeah, this is the problem in PO's x86utm that I mentioned in response to your previous counter-example code:-a it does not bother to support the
    BSS segment.-a Because you have initialised depth to zero, the compiler assigns it to the BSS segment (which contains zeroed storage), but PO
    never maps that to anything.-a Hence its assignment to virtual address 00000000 in the trace.-a I also mentioned the x86utm bug where PO only process relocations in the code segment, although that does not impact
    your code here.-a Looks like PO didn't see my comments and rush to fix
    his code!

    If PO fixed x86utm it would behave as you've described.-a An alternative bypass would be for you to initialise depth to 1, so the compiler will
    map it to the DATA segment rather than BSS.-a (x86utm handles the DATA segment.)-a Then in HHHH you could test "if (depth > 1)" instead of "if (depth > 0)".


    Mike.

    I have no time for goose chases, changing one word
    (interested below) fixed the problem

    There does not exist any implementation of C function
    HHH that [ONLY] simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    I wasted 15 years by tolerating Ben Bacarisse
    change-the-subject form of rebuttal.

    In a very optimistic projection, am 71, recovered
    from cancer twice since 2022, still recovering
    from very severe PJP pneumonia it is very doubtful
    that I have 15 years left.

    I really want to get my work validated ASAP
    and before I die.

    This will only take about 2 hours of review
    by a competent person that has no interest
    in rebuttal.
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 11:11:23 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being wrong
    about something in regards to it, at least once???
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 13:24:30 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being wrong
    about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    01 int DD()
    02 {
    03 int Halt_Status = HHH(DD);
    04 if (Halt_Status)
    05 HERE: goto HERE;
    06 return Halt_Status;
    07 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.
    --
    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 Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 15:09:53 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being wrong
    about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.

    Moron?

    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 18:51:41 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being wrong
    about something in regards to it, at least once???


    Here is my work from 22 years ago

    As I first published back in 2004:
    On 6/23/2004 9:34 PM, Olcott wrote: [comp.theory, sci.logic]

    function LoopIfYouSayItHalts (bool YouSayItHalts):
    if YouSayItHalts () then
    while true do {}
    else
    return false;

    Does this program Halt?

    (Your (YES or NO) answer is to be considered
    translated to Boolean as the function's input
    parameter)

    Please ONLY PROVIDE CORRECT ANSWERS!

    I proved that the Halting Problem counter-example
    input is just the Liar Paradox in disguise back
    in 2004.
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 20:10:21 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being wrong
    about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the invariant
    that HHH not cut DD simulation's short after the recursion is demonstrated

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 21:29:16 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to testing
    for non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt
    decider') then yes, HHH(DD) would be stuck in a pattern of infinite
    recursion, but then it also wouldn't be the HHH which he claims to
    be a potential halt decider, so the argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY in
    your new formulation. I'd offered my interpretation, but you neither
    confirm nor deny it. How does repeating three things verbatim from
    your previous posts offer any sort of clarification?

    Communication is not your strong point. Maybe try working on that by
    actually providing the requested clarification. What does the word
    ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit of
    doing this -- people ask questions or for clarifications and you simply
    repost stuff we've all already read which doesn't actually answer
    anything. If what you posted wasn't clear the first time, repeating it
    isn't going to provide any clarification.

    You'd been asked to clarify what you thought the inclusion of the word
    'ONLY' in your new wording accomplishes. I'd given my best guess as to
    what you meant by this [still present in the above quoted text], but
    your reply above leaves me none the wiser about whether I was on the
    right track.

    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 comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 22:50:34 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct? >>>>>
    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being wrong
    about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the invariant that HHH not cut DD simulation's short after the recursion is demonstrated


    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is recursive

    sipser said that same thing polcott

    --
    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,comp.ai.philosophy on Wed Nov 11 22:52:05 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to testing
    for non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt
    decider') then yes, HHH(DD) would be stuck in a pattern of infinite >>>>> recursion, but then it also wouldn't be the HHH which he claims to
    be a potential halt decider, so the argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY in
    your new formulation. I'd offered my interpretation, but you neither
    confirm nor deny it. How does repeating three things verbatim from
    your previous posts offer any sort of clarification?

    Communication is not your strong point. Maybe try working on that by
    actually providing the requested clarification. What does the word
    ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit of
    doing this -- people ask questions or for clarifications and you simply repost stuff we've all already read which doesn't actually answer
    anything. If what you posted wasn't clear the first time, repeating it
    isn't going to provide any clarification.

    You'd been asked to clarify what you thought the inclusion of the word 'ONLY' in your new wording accomplishes. I'd given my best guess as to
    what you meant by this [still present in the above quoted text], but
    your reply above leaves me none the wiser about whether I was on the
    right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Wed Nov 11 23:16:14 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct? >>>>>>
    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated. HHH only actually demonstrates one step of recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH does
    break that invariant, so invalidating the induction requires to prove
    infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott



    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Thu Nov 12 00:02:59 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct? >>>>>>>
    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    01 int DD2()
    02 {
    03 int Halt_Status = HHH(DD2);
    04 if (Halt_Status)
    05 HERE: goto HERE;
    06 HERE2: goto HERE2;
    07 }

    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does _not_
    halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
    of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated. HHH only actually demonstrates one step of recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott




    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 13:11:19 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "If I was not correct then at least one person
    could point to an actual error in the last 22 years."

    FOR FUCK'S SAKE, PETER.

    Just a few hours ago, you wrote:

    "Even if your code does prove its point
    that only would show that the dbush
    words are incorrect."

    Then you announced:

    "So I add one word. DONE !!!"

    YOU CHANGED YOUR CLAIM TO ESCAPE A COUNTEREXAMPLE.

    And now you boast that nobody has found an error in 22 years?

    More fundamentally, the absence of an error YOU ACCEPT is not evidence
    that your proof is correct.

    Nor is the number of years you have defended it.

    You claim to have reduced computable functions to their "simplest possible essence".

    Wonderful.

    Then it should be particularly easy to provide:

    1. A precise mathematical definition of "ONLY simulates".
    2. A formal statement of your theorem.
    3. A proof establishing that theorem from its hypotheses.

    No complaints about reviewers.

    No appeals to your 22 years of effort.

    No more moving the goalposts.

    JUST THE MATHEMATICS.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 13:12:40 2026
    From Newsgroup: comp.ai.philosophy

    Le 12/11/2026 |a 05:52, olcott a |-crit :
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to testing >>>>>> for non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt
    decider') then yes, HHH(DD) would be stuck in a pattern of infinite >>>>>> recursion, but then it also wouldn't be the HHH which he claims to >>>>>> be a potential halt decider, so the argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY in
    your new formulation. I'd offered my interpretation, but you neither
    confirm nor deny it. How does repeating three things verbatim from
    your previous posts offer any sort of clarification?

    Communication is not your strong point. Maybe try working on that by
    actually providing the requested clarification. What does the word
    ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit of
    doing this -- people ask questions or for clarifications and you simply
    repost stuff we've all already read which doesn't actually answer
    anything. If what you posted wasn't clear the first time, repeating it
    isn't going to provide any clarification.

    You'd been asked to clarify what you thought the inclusion of the word
    'ONLY' in your new wording accomplishes. I'd given my best guess as to
    what you meant by this [still present in the above quoted text], but
    your reply above leaves me none the wiser about whether I was on the
    right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Peter,

    "It avoids the possible issue that Python raised."

    WE KNOW WHY YOU ADDED "ONLY", PETER.

    WE ARE ASKING WHAT IT MEANS.

    Andr|- has asked you repeatedly.

    I have asked you repeatedly.

    You keep explaining your MOTIVATION instead of defining your TERM.

    Let us consider Andr|-'s interpretation:

    If "ONLY simulates" means that HHH faithfully executes DD's instructions without any additional mechanism for detecting nontermination or aborting
    the simulation, then yes, a simulation of a nonterminating DD will never
    reach DD's return statement.

    SO WHAT?

    That is simply what faithful simulation of a nonterminating computation
    means.

    It establishes absolutely nothing about the correctness of your alleged
    halt decider.

    Indeed, under that interpretation, HHH is no longer the halt decider you
    claim to have constructed.

    On the other hand, if "ONLY simulates" permits detecting infinite
    execution patterns and aborting the simulation, then you must explain precisely which additional operations are permitted and why your detector
    is sound.

    You cannot have it both ways.

    And your excursion into Post canonical systems and semi-Thue systems
    changes NOTHING.

    Turing-equivalent models do not magically make nontermination decidable.

    So answer Andr|-'s perfectly straightforward question:

    WHAT EXACTLY DOES "ONLY" EXCLUDE?

    Not WHY you added it.

    WHAT IT MEANS.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 06:34:44 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-11 21:52, olcott wrote:
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to testing >>>>>> for non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt
    decider') then yes, HHH(DD) would be stuck in a pattern of
    infinite recursion, but then it also wouldn't be the HHH which he >>>>>> claims to be a potential halt decider, so the argument falls apart. >>>>>>
    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY in
    your new formulation. I'd offered my interpretation, but you neither
    confirm nor deny it. How does repeating three things verbatim from
    your previous posts offer any sort of clarification?

    Communication is not your strong point. Maybe try working on that by
    actually providing the requested clarification. What does the word
    ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit of
    doing this -- people ask questions or for clarifications and you
    simply repost stuff we've all already read which doesn't actually
    answer anything. If what you posted wasn't clear the first time,
    repeating it isn't going to provide any clarification.

    You'd been asked to clarify what you thought the inclusion of the word
    'ONLY' in your new wording accomplishes. I'd given my best guess as to
    what you meant by this [still present in the above quoted text], but
    your reply above leaves me none the wiser about whether I was on the
    right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Now you're just being an ass. If it were obvious I wouldn't be asking
    for clarification.

    Above I wrote that I thought by ONLY simulates DD you meant simulates as opposed to simulates with the possibility of aborting DD.

    I'm asking for a simple confirmation or denial that this is what you meant.

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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From polcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 08:47:53 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct? >>>>>>>
    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated. HHH only actually demonstrates one step of recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

    <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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott




    --
    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@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 15:32:02 2026
    From Newsgroup: comp.ai.philosophy


    "Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?"

    READ YOUR OWN QUOTATION.

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

    CORRECTLY DETERMINES.

    THOSE ARE THE KEY WORDS.

    Observing recursive calls does not, by itself, establish infinite
    recursion.

    Aborting a simulation does not establish that the simulated program would never halt.

    And repeatedly asserting that your detector is correct is NOT A PROOF OF
    ITS CORRECTNESS.

    Dart200 has explained the problem:

    Your HHH observes a finite execution prefix and then aborts the
    simulation.

    You claim that the execution WOULD HAVE continued forever.

    THAT IS THE CLAIM YOU MUST PROVE.

    You cannot use the hypothetical infinite continuation as evidence for the correctness of the abort decision, and then use that decision as proof of
    the infinite continuation.

    THAT IS CIRCULAR REASONING.

    Furthermore, your quotation is CONDITIONAL.

    Even if Sipser agreed with every word of it, that would not establish that your implementation satisfies its premise.

    "If H correctly determines X" does not mean "Olcott's H correctly
    determines X".

    FOR FUCK'S SAKE, PETER.

    You have spent years repeating the word "correctly" where a proof of correctness is required.

    SHOW THAT YOUR FINITE OBSERVATION NECESSARILY IMPLIES NONTERMINATION.

    Or stop pretending that quoting a conditional statement establishes its premise.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From polcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 11:11:46 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 21:52, olcott wrote:
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to
    testing for non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt >>>>>>> decider') then yes, HHH(DD) would be stuck in a pattern of
    infinite recursion, but then it also wouldn't be the HHH which he >>>>>>> claims to be a potential halt decider, so the argument falls apart. >>>>>>>
    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY in
    your new formulation. I'd offered my interpretation, but you
    neither confirm nor deny it. How does repeating three things
    verbatim from your previous posts offer any sort of clarification?

    Communication is not your strong point. Maybe try working on that
    by actually providing the requested clarification. What does the
    word ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit of
    doing this -- people ask questions or for clarifications and you
    simply repost stuff we've all already read which doesn't actually
    answer anything. If what you posted wasn't clear the first time,
    repeating it isn't going to provide any clarification.

    You'd been asked to clarify what you thought the inclusion of the
    word 'ONLY' in your new wording accomplishes. I'd given my best guess
    as to what you meant by this [still present in the above quoted
    text], but your reply above leaves me none the wiser about whether I
    was on the right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Now you're just being an ass. If it were obvious I wouldn't be asking
    for clarification.

    Above I wrote that I thought by ONLY simulates DD you meant simulates as opposed to simulates with the possibility of aborting DD.


    While being simulated

    I'm asking for a simple confirmation or denial that this is what you meant.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    If the simulated DD stops being simulated then it
    suddenly becomes a static text string.
    --
    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 olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 11:40:12 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct? >>>>>>>
    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of
    recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

    <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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott




    --
    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 11:11:09 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-12 10:11, polcott wrote:
    On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 21:52, olcott wrote:
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to
    testing for non-halting patterns and subsequently aborting DD. >>>>>>>>
    If HHH /were/ a pure simulator (as opposed to a 'simulating halt >>>>>>>> decider') then yes, HHH(DD) would be stuck in a pattern of
    infinite recursion, but then it also wouldn't be the HHH which >>>>>>>> he claims to be a potential halt decider, so the argument falls >>>>>>>> apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY in >>>>>> your new formulation. I'd offered my interpretation, but you
    neither confirm nor deny it. How does repeating three things
    verbatim from your previous posts offer any sort of clarification? >>>>>>
    Communication is not your strong point. Maybe try working on that >>>>>> by actually providing the requested clarification. What does the
    word ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit of
    doing this -- people ask questions or for clarifications and you
    simply repost stuff we've all already read which doesn't actually
    answer anything. If what you posted wasn't clear the first time,
    repeating it isn't going to provide any clarification.

    You'd been asked to clarify what you thought the inclusion of the
    word 'ONLY' in your new wording accomplishes. I'd given my best
    guess as to what you meant by this [still present in the above
    quoted text], but your reply above leaves me none the wiser about
    whether I was on the right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Now you're just being an ass. If it were obvious I wouldn't be asking
    for clarification.

    Above I wrote that I thought by ONLY simulates DD you meant simulates
    as opposed to simulates with the possibility of aborting DD.


    While being simulated

    That doesn't clarify anything. It's not even a complete sentence. It
    certainly makes no mention of what you mean by ONLY.

    I'm asking for a simple confirmation or denial that this is what you
    meant.

    Is the above really too much to ask?

    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    You've already posted the above numerous times. Posting it yet one more
    time isn't going to make it any clearer.

    Andr|-

    If the simulated DD stops being simulated then it
    suddenly becomes a static text string.

    --
    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 comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 12:31:18 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 7:11 AM, Python wrote:
    Peter,

    -a-a "If I was not correct then at least one person
    -a-a-a could point to an actual error in the last 22 years."

    FOR FUCK'S SAKE, PETER.

    Just a few hours ago, you wrote:

    -a-a "Even if your code does prove its point
    -a-a-a that only would show that the dbush
    -a-a-a words are incorrect."

    Then you announced:

    -a-a "So I add one word. DONE !!!"

    YOU CHANGED YOUR CLAIM TO ESCAPE A COUNTEREXAMPLE.

    And now you boast that nobody has found an error in 22 years?


    Inaccurate paraphrase. I am not dbush.
    I will only address one single point per reply.
    No one has pointed out any material error with the
    essence of what I have been saying for 22 years.

    I will explicitly state that essence now:
    There is something fundamentally incorrect with the
    Halting Problem proofs.

    More fundamentally, the absence of an error YOU ACCEPT is not evidence
    that your proof is correct.

    Nor is the number of years you have defended it.

    You claim to have reduced computable functions to their "simplest
    possible essence".

    Wonderful.

    Then it should be particularly easy to provide:

    1. A precise mathematical definition of "ONLY simulates".
    2. A formal statement of your theorem.
    3. A proof establishing that theorem from its hypotheses.

    No complaints about reviewers.

    No appeals to your 22 years of effort.

    No more moving the goalposts.

    JUST THE MATHEMATICS.
    --
    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,comp.ai.philosophy on Thu Nov 12 12:33:38 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 7:12 AM, Python wrote:
    Le 12/11/2026 |a 05:52, olcott a |-crit :
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to
    testing for non-halting patterns and subsequently aborting DD.

    If HHH /were/ a pure simulator (as opposed to a 'simulating halt >>>>>>> decider') then yes, HHH(DD) would be stuck in a pattern of
    infinite recursion, but then it also wouldn't be the HHH which he >>>>>>> claims to be a potential halt decider, so the argument falls apart. >>>>>>>
    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation
    All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY in
    your new formulation. I'd offered my interpretation, but you
    neither confirm nor deny it. How does repeating three things
    verbatim from your previous posts offer any sort of clarification?

    Communication is not your strong point. Maybe try working on that
    by actually providing the requested clarification. What does the
    word ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit of
    doing this -- people ask questions or for clarifications and you
    simply repost stuff we've all already read which doesn't actually
    answer anything. If what you posted wasn't clear the first time,
    repeating it isn't going to provide any clarification.

    You'd been asked to clarify what you thought the inclusion of the
    word 'ONLY' in your new wording accomplishes. I'd given my best guess
    as to what you meant by this [still present in the above quoted
    text], but your reply above leaves me none the wiser about whether I
    was on the right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Peter,

    -a-a "It avoids the possible issue that Python raised."

    WE KNOW WHY YOU ADDED "ONLY", PETER.

    WE ARE ASKING WHAT IT MEANS.


    Please explain how this is not a head game.

    Andr|- has asked you repeatedly.

    I have asked you repeatedly.

    You keep explaining your MOTIVATION instead of defining your TERM.

    Let us consider Andr|-'s interpretation:

    If "ONLY simulates" means that HHH faithfully executes DD's instructions without any additional mechanism for detecting nontermination or
    aborting the simulation, then yes, a simulation of a nonterminating DD
    will never reach DD's return statement.

    SO WHAT?


    It executes nothing. Bad paraphrase.

    That is simply what faithful simulation of a nonterminating computation means.

    It establishes absolutely nothing about the correctness of your alleged
    halt decider.

    Indeed, under that interpretation, HHH is no longer the halt decider you claim to have constructed.

    On the other hand, if "ONLY simulates" permits detecting infinite
    execution patterns and aborting the simulation, then you must explain precisely which additional operations are permitted and why your
    detector is sound.

    You cannot have it both ways.

    And your excursion into Post canonical systems and semi-Thue systems
    changes NOTHING.

    Turing-equivalent models do not magically make nontermination decidable.

    So answer Andr|-'s perfectly straightforward question:

    WHAT EXACTLY DOES "ONLY" EXCLUDE?

    Not WHY you added it.

    WHAT IT MEANS.
    --
    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,comp.ai.philosophy on Thu Nov 12 12:39:12 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 9:32 AM, Python wrote:

    -a-a "Are you going to keep pretending that the Professor
    -a-a-a Sipser approved criteria has not been met?"

    READ YOUR OWN QUOTATION.

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

    CORRECTLY DETERMINES.

    THOSE ARE THE KEY WORDS.


    I have argued about this for three years
    where people just refused to acknowledge
    that a C interpreter that is simulating
    C code correctness is determined by the
    operational semantics of the C programming
    language.

    I WILL NOT PLAY THOSE HEAD GAMES ANY MORE.

    Observing recursive calls does not, by itself, establish infinite
    recursion.


    It took four years for the dishonest people on
    this forum to acknowledge that there was any steps
    of recursive simulation AT ALL.

    Aborting a simulation does not establish that the simulated program
    would never halt.

    And repeatedly asserting that your detector is correct is NOT A PROOF OF
    ITS CORRECTNESS.

    Dart200 has explained the problem:

    Your HHH observes a finite execution prefix and then aborts the simulation.

    You claim that the execution WOULD HAVE continued forever.

    THAT IS THE CLAIM YOU MUST PROVE.

    You cannot use the hypothetical infinite continuation as evidence for
    the correctness of the abort decision, and then use that decision as
    proof of the infinite continuation.

    THAT IS CIRCULAR REASONING.

    Furthermore, your quotation is CONDITIONAL.

    Even if Sipser agreed with every word of it, that would not establish
    that your implementation satisfies its premise.

    "If H correctly determines X" does not mean "Olcott's H correctly
    determines X".

    FOR FUCK'S SAKE, PETER.

    You have spent years repeating the word "correctly" where a proof of correctness is required.

    SHOW THAT YOUR FINITE OBSERVATION NECESSARILY IMPLIES NONTERMINATION.

    Or stop pretending that quoting a conditional statement establishes its premise.
    --
    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,comp.ai.philosophy on Thu Nov 12 12:52:01 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 12:11 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 10:11, polcott wrote:
    On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 21:52, olcott wrote:
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to
    testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>
    If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a pattern of >>>>>>>>> infinite recursion, but then it also wouldn't be the HHH which >>>>>>>>> he claims to be a potential halt decider, so the argument falls >>>>>>>>> apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation >>>>>>>> All Turing equivalent computations can be reduced to applying
    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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY >>>>>>> in your new formulation. I'd offered my interpretation, but you >>>>>>> neither confirm nor deny it. How does repeating three things
    verbatim from your previous posts offer any sort of clarification? >>>>>>>
    Communication is not your strong point. Maybe try working on that >>>>>>> by actually providing the requested clarification. What does the >>>>>>> word ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit
    of doing this -- people ask questions or for clarifications and you >>>>> simply repost stuff we've all already read which doesn't actually
    answer anything. If what you posted wasn't clear the first time,
    repeating it isn't going to provide any clarification.

    You'd been asked to clarify what you thought the inclusion of the
    word 'ONLY' in your new wording accomplishes. I'd given my best
    guess as to what you meant by this [still present in the above
    quoted text], but your reply above leaves me none the wiser about
    whether I was on the right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Now you're just being an ass. If it were obvious I wouldn't be asking
    for clarification.

    Above I wrote that I thought by ONLY simulates DD you meant simulates
    as opposed to simulates with the possibility of aborting DD.


    While being simulated

    That doesn't clarify anything. It's not even a complete sentence. It certainly makes no mention of what you mean by ONLY.

    I'm asking for a simple confirmation or denial that this is what you
    meant.

    Is the above really too much to ask?

    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.


    You've already posted the above numerous times. Posting it yet one more
    time isn't going to make it any clearer.

    Andr|-

    If the simulated DD stops being simulated then it
    suddenly becomes a static text string.


    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 11:07:10 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT
    correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial
    recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not infinite.
    the infinite recursion only occurs if HHH doesn't break the invariant
    of letting the simulation run, but HHH does break that invariant, so
    invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the decision
    is _not_ valid if DD is then aborted EfOa




    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott






    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 13:43:04 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not infinite.
    the infinite recursion only occurs if HHH doesn't break the invariant
    of letting the simulation run, but HHH does break that invariant, so
    invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the decision
    is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 12:26:20 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 11:43 AM, olcott wrote:
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not infinite.
    the infinite recursion only occurs if HHH doesn't break the
    invariant of letting the simulation run, but HHH does break that
    invariant, so invalidating the induction requires to prove infinite
    recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the
    decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.


    ok so what does "unless aborted then" mean polcott?
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 12:33:48 2026
    From Newsgroup: comp.ai.philosophy

    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct? >>>>>>>
    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast the shit
    out of a threads stack... I made a manual recursion for AppleSoft BASIC
    for fun while trying to port some of my algos to it:

    https://pastebin.com/raw/Effeg8cK

    100 REM ct_vfield_applesoft_basic
    110 HOME
    120 HGR: HCOLOR = 3: VTAB 22
    130 PRINT "ct_vfield_applesoft_basic"
    140 GOSUB 1000
    150 GOSUB 3000
    160 SP = 0
    170 RS(SP, 0) = 0
    180 RS(SP, 1) = -1
    190 RS(SP, 2) = 0
    200 RS(SP, 3) = 1
    210 RS(SP, 4) = 0
    220 GOSUB 8000
    230 V1(1) = 0: V1(2) = 0: V1(3) = 1: V1(4) = 128
    240 GOSUB 6000
    245 PRINT "Chris Thomasson's Koch Complete!"
    250 END

    1000 REM ct_init
    1010 PRINT "ct_init"
    1020 DIM A0(6)
    1030 DIM V0(4)
    1040 DIM V1(4)
    1050 DIM V2(4)
    1060 DIM V3(4)
    1070 DIM V4(4)
    1080 DIM V5(4)
    1090 RN = 3
    1100 DIM RS(RN, 16)
    1110 GOSUB 2000
    1120 RETURN

    2000 REM ct_init_plane
    2010 PRINT "ct_init_plane"
    2020 A0(1) = 279: REM m_plane.m_width
    2030 A0(2) = 191: REM m_plane.m_height
    2040 A0(3) = 0.0126106: REM m_plane.m_xstep
    2050 A0(4) = 0.0126316: REM m_plane.m_ystep
    2060 A0(5) = -1.75288: REM m_plane.m_axes.m_xmin
    2070 A0(6) = 1.2: REM m_plane.m_axes.m_ymax
    2080 RETURN

    3000 REM ct_display_plane
    3010 PRINT "ct_display_plane"
    3020 FOR I0 = 1 TO 6
    3030 PRINT "A0("; I0; ") = " A0(I0)
    3040 NEXT I0
    3050 RETURN

    4000 REM ct_project_point
    4010 REM PRINT "ct_project_point"
    4020 V0(3) = (V0(1) - A0(5)) / A0(3)
    4030 V0(4) = (A0(6) - V0(2)) / A0(4)
    4040 IF V0(3) < 0 THEN V0(3) = INT(V0(3) - .5)
    4050 IF V0(3) >= 0 THEN V0(3) = INT(V0(3) + .5)
    4060 IF V0(4) < 0 THEN V0(4) = INT(V0(4) - .5)
    4070 IF V0(4) >= 0 THEN V0(4) = INT(V0(4) + .5)
    4080 RETURN

    5000 REM ct_plot_point
    5010 REM PRINT "ct_plot_point"
    5020 GOSUB 4000
    5030 IF V0(3) > -1 AND V0(3) <= A0(1) AND V0(4) > -1 AND V0(4) <=
    A0(2) THEN HPLOT V0(3), V0(4)
    5040 RETURN

    6000 REM ct_plot_circle
    6010 PRINT "ct_plot_circle"
    6020 AB = 6.28318 / V1(4)
    6030 FOR I1 = 0 TO 6.28318 STEP AB
    6040 V0(1) = V1(1) + COS(I1) * V1(3)
    6050 V0(2) = V1(2) + SIN(I1) * V1(3)
    6060 GOSUB 5000
    6070 NEXT I1
    6080 RETURN

    7000 REM ct_plot_line
    7010 PRINT "ct_plot_line"
    7020 V0(1) = V5(1): V0(2) = V5(2)
    7030 GOSUB 4000
    7040 IF V0(3) < 0 THEN V0(3) = 0
    7050 IF V0(3) > A0(1) THEN V0(3) = A0(1)
    7060 IF V0(4) < 0 THEN V0(4) = 0
    7070 IF V0(4) > A0(2) THEN V0(4) = A0(2)
    7080 HPLOT V0(3), V0(4)
    7090 V0(1) = V5(3): V0(2) = V5(4)
    7100 GOSUB 4000
    7110 IF V0(3) < 0 THEN V0(3) = 0
    7120 IF V0(3) > A0(1) THEN V0(3) = A0(1)
    7130 IF V0(4) < 0 THEN V0(4) = 0
    7140 IF V0(4) > A0(2) THEN V0(4) = A0(2)
    7150 HPLOT TO V0(3), V0(4)
    7160 RETURN

    8000 REM ct_koch
    8010 IF RS(SP, 0) >= RN THEN RETURN
    8020 PRINT "ct_koch = "; RS(SP, 0); " "; RS(SP, 1); " "; RS(SP, 2);
    " "; RS(SP, 3); " "; RS(SP, 4)"
    8030 RS(SP, 5) = RS(SP, 3) - RS(SP, 1) : REM difx
    8040 RS(SP, 6) = RS(SP, 4) - RS(SP, 2) : REM dify
    8050 RS(SP, 7) = RS(SP, 1) + RS(SP, 5) / 2 : REM dify
    8060 RS(SP, 8) = RS(SP, 2) + RS(SP, 6) / 2 : REM dify
    8070 RS(SP, 9) = -RS(SP, 6) : REM perpx
    8080 RS(SP, 10) = RS(SP, 5) : REM perpy
    8090 RS(SP, 11) = RS(SP, 7) + RS(SP, 9) / 3 : REM tipx
    8100 RS(SP, 12) = RS(SP, 8) + RS(SP, 10) / 3 : REM tipy
    8110 RS(SP, 13) = RS(SP, 1) + RS(SP, 5) / 3 : REM k0x
    8120 RS(SP, 14) = RS(SP, 2) + RS(SP, 6) / 3 : REM k0y
    8130 RS(SP, 15) = RS(SP, 3) - RS(SP, 5) / 3 : REM k1x
    8140 RS(SP, 16) = RS(SP, 4) - RS(SP, 6) / 3 : REM k1y

    8145 IF RS(SP, 0) < RN - 1 GOTO 8230
    8150 V5(1) = RS(SP, 1): V5(2) = RS(SP, 2): V5(3) = RS(SP, 13): V5(4)
    = RS(SP, 14)
    8160 GOSUB 7000
    8170 V5(1) = RS(SP, 13): V5(2) = RS(SP, 14): V5(3) = RS(SP, 11):
    V5(4) = RS(SP, 12)
    8180 GOSUB 7000
    8190 V5(1) = RS(SP, 11): V5(2) = RS(SP, 12): V5(3) = RS(SP, 15):
    V5(4) = RS(SP, 16)
    8200 GOSUB 7000
    8210 V5(1) = RS(SP, 15): V5(2) = RS(SP, 16): V5(3) = RS(SP, 3):
    V5(4) = RS(SP, 4)
    8220 GOSUB 7000

    8230 REM line 0
    8240 SP = SP + 1
    8250 RS(SP, 0) = RS(SP - 1, 0) + 1
    8260 RS(SP, 1) = RS(SP - 1, 1)
    8270 RS(SP, 2) = RS(SP - 1, 2)
    8280 RS(SP, 3) = RS(SP - 1, 13)
    8290 RS(SP, 4) = RS(SP - 1, 14)
    8300 GOSUB 8000
    8310 SP = SP - 1
    8320 REM line 1
    8330 SP = SP + 1
    8340 RS(SP, 0) = RS(SP - 1, 0) + 1
    8350 RS(SP, 1) = RS(SP - 1, 13)
    8360 RS(SP, 2) = RS(SP - 1, 14)
    8370 RS(SP, 3) = RS(SP - 1, 11)
    8380 RS(SP, 4) = RS(SP - 1, 12)
    8390 GOSUB 8000
    8400 SP = SP - 1
    8410 REM line 2
    8420 SP = SP + 1
    8430 RS(SP, 0) = RS(SP - 1, 0) + 1
    8440 RS(SP, 1) = RS(SP - 1, 11)
    8450 RS(SP, 2) = RS(SP - 1, 12)
    8460 RS(SP, 3) = RS(SP - 1, 15)
    8470 RS(SP, 4) = RS(SP - 1, 16)
    8480 GOSUB 8000
    8490 SP = SP - 1
    8500 REM line 3
    8510 SP = SP + 1
    8520 RS(SP, 0) = RS(SP - 1, 0) + 1
    8530 RS(SP, 1) = RS(SP - 1, 15)
    8540 RS(SP, 2) = RS(SP - 1, 16)
    8550 RS(SP, 3) = RS(SP - 1, 3)
    8560 RS(SP, 4) = RS(SP - 1, 4)
    8570 GOSUB 8000
    8580 SP = SP - 1
    8590 RETURN



    HHH only actually demonstrates one step of
    recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott





    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 12:40:51 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT
    correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial
    recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast the shit
    out of a threads stack... I made a manual recursion for AppleSoft BASIC
    for fun while trying to port some of my algos to it:

    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-


    https://pastebin.com/raw/Effeg8cK

    100 REM ct_vfield_applesoft_basic
    110-a-a-a-a HOME
    120-a-a-a-a HGR: HCOLOR = 3: VTAB 22
    130-a-a-a-a PRINT "ct_vfield_applesoft_basic"
    140-a-a-a-a GOSUB 1000
    150-a-a-a-a GOSUB 3000
    160-a-a-a-a SP = 0
    170-a-a-a-a RS(SP, 0) = 0
    180-a-a-a-a RS(SP, 1) = -1
    190-a-a-a-a RS(SP, 2) = 0
    200-a-a-a-a RS(SP, 3) = 1
    210-a-a-a-a RS(SP, 4) = 0
    220-a-a-a-a GOSUB 8000
    230-a-a-a-a V1(1) = 0: V1(2) = 0: V1(3) = 1: V1(4) = 128
    240-a-a-a-a GOSUB 6000
    245-a-a-a-a PRINT "Chris Thomasson's Koch Complete!"
    250 END

    1000 REM ct_init
    1010-a-a-a-a PRINT "ct_init"
    1020-a-a-a-a DIM A0(6)
    1030-a-a-a-a DIM V0(4)
    1040-a-a-a-a DIM V1(4)
    1050-a-a-a-a DIM V2(4)
    1060-a-a-a-a DIM V3(4)
    1070-a-a-a-a DIM V4(4)
    1080-a-a-a-a DIM V5(4)
    1090-a-a-a-a RN = 3
    1100-a-a-a-a DIM RS(RN, 16)
    1110-a-a-a-a-a-a-a-a GOSUB 2000
    1120 RETURN

    2000 REM ct_init_plane
    2010-a-a-a-a PRINT "ct_init_plane"
    2020-a-a-a-a A0(1) = 279: REM m_plane.m_width
    2030-a-a-a-a A0(2) = 191: REM m_plane.m_height
    2040-a-a-a-a A0(3) = 0.0126106: REM m_plane.m_xstep
    2050-a-a-a-a A0(4) = 0.0126316: REM m_plane.m_ystep
    2060-a-a-a-a A0(5) = -1.75288: REM m_plane.m_axes.m_xmin
    2070-a-a-a-a A0(6) = 1.2: REM m_plane.m_axes.m_ymax
    2080 RETURN

    3000 REM ct_display_plane
    3010-a-a-a-a PRINT "ct_display_plane"
    3020-a-a-a-a FOR I0 = 1 TO 6
    3030-a-a-a-a-a-a-a-a PRINT "A0("; I0; ") = " A0(I0)
    3040-a-a-a-a NEXT I0
    3050 RETURN

    4000 REM ct_project_point
    4010-a-a-a-a REM PRINT "ct_project_point"
    4020-a-a-a-a V0(3) = (V0(1) - A0(5)) / A0(3)
    4030-a-a-a-a V0(4) = (A0(6) - V0(2)) / A0(4)
    4040-a-a-a-a IF V0(3) < 0 THEN V0(3) = INT(V0(3) - .5)
    4050-a-a-a-a IF V0(3) >= 0 THEN V0(3) = INT(V0(3) + .5)
    4060-a-a-a-a IF V0(4) < 0 THEN V0(4) = INT(V0(4) - .5)
    4070-a-a-a-a IF V0(4) >= 0 THEN V0(4) = INT(V0(4) + .5)
    4080 RETURN

    5000 REM ct_plot_point
    5010-a-a-a-a REM PRINT "ct_plot_point"
    5020-a-a-a-a GOSUB 4000
    5030-a-a-a-a IF V0(3) > -1 AND V0(3) <= A0(1) AND V0(4) > -1 AND V0(4) <= A0(2) THEN HPLOT V0(3), V0(4)
    5040 RETURN

    6000 REM ct_plot_circle
    6010-a-a-a-a PRINT "ct_plot_circle"
    6020-a-a-a-a AB = 6.28318 / V1(4)
    6030-a-a-a-a FOR I1 = 0 TO 6.28318 STEP AB
    6040-a-a-a-a-a-a-a-a V0(1) = V1(1) + COS(I1) * V1(3)
    6050-a-a-a-a-a-a-a-a V0(2) = V1(2) + SIN(I1) * V1(3)
    6060-a-a-a-a-a-a-a-a GOSUB 5000
    6070-a-a-a-a NEXT I1
    6080 RETURN

    7000 REM ct_plot_line
    7010-a-a-a-a PRINT "ct_plot_line"
    7020-a-a-a-a V0(1) = V5(1): V0(2) = V5(2)
    7030-a-a-a-a GOSUB 4000
    7040-a-a-a-a IF V0(3) < 0 THEN V0(3) = 0
    7050-a-a-a-a IF V0(3) > A0(1) THEN V0(3) = A0(1)
    7060-a-a-a-a IF V0(4) < 0 THEN V0(4) = 0
    7070-a-a-a-a IF V0(4) > A0(2) THEN V0(4) = A0(2)
    7080-a-a-a-a HPLOT V0(3), V0(4)
    7090-a-a-a-a V0(1) = V5(3): V0(2) = V5(4)
    7100-a-a-a-a GOSUB 4000
    7110-a-a-a-a IF V0(3) < 0 THEN V0(3) = 0
    7120-a-a-a-a IF V0(3) > A0(1) THEN V0(3) = A0(1)
    7130-a-a-a-a IF V0(4) < 0 THEN V0(4) = 0
    7140-a-a-a-a IF V0(4) > A0(2) THEN V0(4) = A0(2)
    7150-a-a-a-a HPLOT TO V0(3), V0(4)
    7160 RETURN

    8000 REM ct_koch
    8010-a-a-a-a IF RS(SP, 0) >= RN THEN RETURN
    8020-a-a-a-a PRINT "ct_koch = "; RS(SP, 0); " "; RS(SP, 1); " "; RS(SP, 2); " "; RS(SP, 3); " "; RS(SP, 4)"
    8030-a-a-a-a RS(SP, 5) = RS(SP, 3) - RS(SP, 1) : REM difx
    8040-a-a-a-a RS(SP, 6) = RS(SP, 4) - RS(SP, 2) : REM dify
    8050-a-a-a-a RS(SP, 7) = RS(SP, 1) + RS(SP, 5) / 2 : REM dify
    8060-a-a-a-a RS(SP, 8) = RS(SP, 2) + RS(SP, 6) / 2 : REM dify
    8070-a-a-a-a RS(SP, 9) = -RS(SP, 6) : REM perpx
    8080-a-a-a-a RS(SP, 10) = RS(SP, 5) : REM perpy
    8090-a-a-a-a RS(SP, 11) = RS(SP, 7) + RS(SP, 9) / 3 : REM tipx
    8100-a-a-a-a RS(SP, 12) = RS(SP, 8) + RS(SP, 10) / 3 : REM tipy
    8110-a-a-a-a RS(SP, 13) = RS(SP, 1) + RS(SP, 5) / 3 : REM k0x
    8120-a-a-a-a RS(SP, 14) = RS(SP, 2) + RS(SP, 6) / 3 : REM k0y
    8130-a-a-a-a RS(SP, 15) = RS(SP, 3) - RS(SP, 5) / 3 : REM k1x
    8140-a-a-a-a RS(SP, 16) = RS(SP, 4) - RS(SP, 6) / 3 : REM k1y

    8145-a-a-a-a IF RS(SP, 0) < RN - 1 GOTO 8230
    8150-a-a-a-a V5(1) = RS(SP, 1): V5(2) = RS(SP, 2): V5(3) = RS(SP, 13): V5(4) = RS(SP, 14)
    8160-a-a-a-a GOSUB 7000
    8170-a-a-a-a V5(1) = RS(SP, 13): V5(2) = RS(SP, 14): V5(3) = RS(SP, 11): V5(4) = RS(SP, 12)
    8180-a-a-a-a GOSUB 7000
    8190-a-a-a-a V5(1) = RS(SP, 11): V5(2) = RS(SP, 12): V5(3) = RS(SP, 15): V5(4) = RS(SP, 16)
    8200-a-a-a-a GOSUB 7000
    8210-a-a-a-a V5(1) = RS(SP, 15): V5(2) = RS(SP, 16): V5(3) = RS(SP, 3): V5(4) = RS(SP, 4)
    8220-a-a-a-a GOSUB 7000

    8230-a-a-a-a REM line 0
    8240-a-a-a-a SP = SP + 1
    8250-a-a-a-a RS(SP, 0) = RS(SP - 1, 0) + 1
    8260-a-a-a-a RS(SP, 1) = RS(SP - 1, 1)
    8270-a-a-a-a RS(SP, 2) = RS(SP - 1, 2)
    8280-a-a-a-a RS(SP, 3) = RS(SP - 1, 13)
    8290-a-a-a-a RS(SP, 4) = RS(SP - 1, 14)
    8300-a-a-a-a GOSUB 8000
    8310-a-a-a-a SP = SP - 1
    8320-a-a-a-a REM line 1
    8330-a-a-a-a SP = SP + 1
    8340-a-a-a-a RS(SP, 0) = RS(SP - 1, 0) + 1
    8350-a-a-a-a RS(SP, 1) = RS(SP - 1, 13)
    8360-a-a-a-a RS(SP, 2) = RS(SP - 1, 14)
    8370-a-a-a-a RS(SP, 3) = RS(SP - 1, 11)
    8380-a-a-a-a RS(SP, 4) = RS(SP - 1, 12)
    8390-a-a-a-a GOSUB 8000
    8400-a-a-a-a SP = SP - 1
    8410-a-a-a-a REM line 2
    8420-a-a-a-a SP = SP + 1
    8430-a-a-a-a RS(SP, 0) = RS(SP - 1, 0) + 1
    8440-a-a-a-a RS(SP, 1) = RS(SP - 1, 11)
    8450-a-a-a-a RS(SP, 2) = RS(SP - 1, 12)
    8460-a-a-a-a RS(SP, 3) = RS(SP - 1, 15)
    8470-a-a-a-a RS(SP, 4) = RS(SP - 1, 16)
    8480-a-a-a-a GOSUB 8000
    8490-a-a-a-a SP = SP - 1
    8500-a-a-a-a REM line 3
    8510-a-a-a-a SP = SP + 1
    8520-a-a-a-a RS(SP, 0) = RS(SP - 1, 0) + 1
    8530-a-a-a-a RS(SP, 1) = RS(SP - 1, 15)
    8540-a-a-a-a RS(SP, 2) = RS(SP - 1, 16)
    8550-a-a-a-a RS(SP, 3) = RS(SP - 1, 3)
    8560-a-a-a-a RS(SP, 4) = RS(SP - 1, 4)
    8570-a-a-a-a GOSUB 8000
    8580-a-a-a-a SP = SP - 1
    8590 RETURN



    HHH only actually demonstrates one step of recursion, not infinite.
    the infinite recursion only occurs if HHH doesn't break the invariant
    of letting the simulation run, but HHH does break that invariant, so
    invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott





    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 14:49:23 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 2:26 PM, dart200 wrote:
    On 11/12/26 11:43 AM, olcott wrote:
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not infinite. >>>>> the infinite recursion only occurs if HHH doesn't break the
    invariant of letting the simulation run, but HHH does break that
    invariant, so invalidating the induction requires to prove infinite >>>>> recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the
    decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.


    ok so what does "unless aborted then" mean polcott?


    All non-halting behavior such as an infinite
    loop will continue to run unless aborted.
    --
    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 Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 12:59:22 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 12:40 PM, dart200 wrote:
    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast the
    shit out of a threads stack... I made a manual recursion for AppleSoft
    BASIC for fun while trying to port some of my algos to it:

    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-

    [...]

    Well, basically to see how portable my algos really are. So far, I have
    all of my fractals that use recursion, and even some of my n-ary vector fields! Let me get an older screenshot of it, I posted it in a BASIC
    group over on the FB... Found it:

    https://i.ibb.co/My8QQRdm/image.png

    Can you see it?

    https://i.ibb.co/My8QQRdm/image.png
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 21:51:20 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "I will only address one single point per reply."

    EXCELLENT.

    ONE POINT IT IS.

    "There is something fundamentally incorrect
    with the Halting Problem proofs."

    WHAT, EXACTLY?

    Identify ONE specific step in the standard diagonal proof that is mathematically invalid.

    Not something you dislike.

    Not something you have redefined.

    Not something you claim to have disproved after 22 years.

    ONE INVALID INFERENCE.

    The standard proof assumes a total, correct halting decider H and
    constructs a program D that does the opposite of what H predicts about D itself.

    If H predicts that D halts, D loops.

    If H predicts that D does not halt, D halts.

    Therefore no such total, correct H exists.

    WHICH STEP IS WRONG?

    You have spent 22 years claiming that something is fundamentally
    incorrect.

    You should be able to identify the error in ONE SENTENCE.

    And please spare us another lecture about Post canonical systems, reviewer qualifications, or the meaning of "ONLY".

    ONE POINT.

    ONE ERROR.

    WHERE IS IT?


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 21:52:02 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Please explain how this is not a head game."

    Because asking you to DEFINE A TERM YOU INTRODUCED is not a head game.

    It is the most elementary requirement of mathematical reasoning.

    You added "ONLY" to exclude my counterexample.

    Andr|- and I asked what that restriction means.

    You answered WHY you added it.

    THAT IS NOT A DEFINITION.

    "It executes nothing. Bad paraphrase."

    Oh, FOR FUCK'S SAKE.

    A simulator need not execute the simulated program's instructions directly
    on the host processor.

    It reproduces their effects on a SIMULATED MACHINE STATE.

    Registers, memory, program counter, stack, control flow.

    THAT IS WHAT SIMULATION MEANS.

    Whether the instructions are interpreted, emulated, or executed natively
    is irrelevant to the distinction we are asking you to clarify.

    So here is the question again:

    Does "ONLY simulates" prohibit HHH from examining the simulated state, recognizing patterns, and aborting the simulation?

    YES OR NO?

    If YES, you have excluded the very mechanism on which your alleged halt decider depends.

    If NO, you must specify which operations are permitted and prove that your nontermination detector is sound.

    There is no head game here.

    There is only a technical question you keep refusing to answer.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 21:52:53 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "a C interpreter that is simulating C code
    correctness is determined by the operational
    semantics of the C programming language."

    YES, PETER.

    A faithful C interpreter must reproduce the operational semantics of the program it simulates.

    NOBODY IS DISPUTING THAT.

    But you are confusing TWO ENTIRELY DIFFERENT CLAIMS:

    1. The simulation correctly reproduces the execution steps observed so
    far.

    2. The simulator correctly determines that the execution will NEVER
    terminate.

    THE FIRST DOES NOT IMPLY THE SECOND.

    "It took four years [...] to acknowledge
    that there was any steps of recursive
    simulation AT ALL."

    And?

    A recursive call is not an infinite recursion.

    Two recursive calls are not an infinite recursion.

    A million recursive calls are not necessarily an infinite recursion.

    A recursive computation can terminate after any finite number of calls.

    To establish nontermination, you need an argument showing that the
    computation cannot reach a terminating state.

    Merely observing recursion is not such an argument.

    And invoking the operational semantics of C does not magically provide
    one.

    Those semantics tell you HOW the computation proceeds.

    They do not give you a general algorithm for deciding WHETHER it will terminate.

    So stop pretending that we are disputing the correctness of C simulation.

    WE ARE DISPUTING YOUR INFERENCE FROM A FINITE SIMULATION TO INFINITE NONTERMINATION.

    And that inference is precisely what you have failed to justify.

    ONE QUESTION:

    What mathematical property of the simulated machine state guarantees that
    DD can NEVER reach its return statement?

    Not that it HASN'T reached it yet.

    That it NEVER WILL.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 13:53:06 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 12:49 PM, olcott wrote:
    On 11/12/2026 2:26 PM, dart200 wrote:
    On 11/12/26 11:43 AM, olcott wrote:
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>

    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>> invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based >>>>>> on the invariant that HHH not cut DD simulation's short after the >>>>>> initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not
    infinite. the infinite recursion only occurs if HHH doesn't break >>>>>> the invariant of letting the simulation run, but HHH does break
    that invariant, so invalidating the induction requires to prove
    infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the
    decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.


    ok so what does "unless aborted then" mean polcott?


    All non-halting behavior such as an infinite
    loop will continue to run unless aborted.


    and what does HHH ultimately do to the simulation of DD?
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 21:54:57 2026
    From Newsgroup: comp.ai.philosophy

    Le 12/11/2026 |a 20:43, olcott a |-crit :
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once? ? ?


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on >>>> the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not infinite.
    the infinite recursion only occurs if HHH doesn't break the invariant >>>> of letting the simulation run, but HHH does break that invariant, so
    invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the decision
    is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.

    Peter,

    "That is not even what those English words mean."

    For once, you have a point.

    Your sentence does NOT say that aborting the simulation automatically invalidates the decision.

    It says:

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

    Fine.

    A simulator MAY abort an execution after correctly establishing that it
    would otherwise run forever.

    NOBODY NEEDS TO DISPUTE THAT.

    But now comes the part you keep conveniently ignoring:

    "H CORRECTLY DETERMINES"

    HOW?

    Your simulator observes a finite sequence of execution steps.

    It detects recursion.

    It aborts.

    And you declare that the computation would never have terminated.

    WHERE IS THE PROOF OF THAT LAST STEP?

    The fact that the simulation was faithful UP TO THE ABORT does not
    establish that its prediction about the infinite future was correct.

    Nor does the fact that Sipser may have accepted your conditional
    statement.

    A conditional statement does not establish its own premise.

    "If H correctly determines nontermination" is perfectly compatible with
    the possibility that YOUR H does NOT correctly determine nontermination.

    You wrote those words.

    You say Sipser approved them.

    VERY WELL.

    NOW PROVE THAT YOUR PROGRAM SATISFIES THEM.

    And please, Peter, don't answer by explaining the operational semantics of
    C for the thousandth time.

    WE AGREE ABOUT FAITHFUL SIMULATION.

    THE QUESTION IS THE CORRECTNESS OF YOUR NONTERMINATION DECISION.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 13:55:24 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
    On 11/12/2026 12:40 PM, dart200 wrote:
    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast the
    shit out of a threads stack... I made a manual recursion for
    AppleSoft BASIC for fun while trying to port some of my algos to it:

    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-

    [...]

    Well, basically to see how portable my algos really are. So far, I have
    all of my fractals that use recursion, and even some of my n-ary vector fields! Let me get an older screenshot of it, I posted it in a BASIC
    group over on the FB... Found it:

    https://i.ibb.co/My8QQRdm/image.png

    Can you see it?

    https://i.ibb.co/My8QQRdm/image.png

    wow pretty nuts ...

    but not as crazy as porting them to the typescript static type checker!

    https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-checker-heres-how-types-execute-code-50i1

    maybe u can do that one next
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 15:59:46 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 3:51 PM, Python wrote:
    Peter,

    -a-a "I will only address one single point per reply."

    EXCELLENT.

    ONE POINT IT IS.

    -a-a "There is something fundamentally incorrect
    -a-a-a with the Halting Problem proofs."

    WHAT, EXACTLY?


    The behavior of H(D) is outside of the scope
    of Turing computation when D calls H(D) in
    the same way that your toaster cannot fill
    your tires with air. That is my bottom line
    up to this minute view.

    Identify ONE specific step in the standard diagonal proof that is mathematically invalid.

    Not something you dislike.

    Not something you have redefined.

    Not something you claim to have disproved after 22 years.

    ONE INVALID INFERENCE.

    The standard proof assumes a total, correct halting decider H and
    constructs a program D that does the opposite of what H predicts about D itself.

    If H predicts that D halts, D loops.

    If H predicts that D does not halt, D halts.

    Therefore no such total, correct H exists.

    WHICH STEP IS WRONG?

    You have spent 22 years claiming that something is fundamentally incorrect.

    You should be able to identify the error in ONE SENTENCE.

    And please spare us another lecture about Post canonical systems,
    reviewer qualifications, or the meaning of "ONLY".

    ONE POINT.

    ONE ERROR.

    WHERE IS IT?
    --
    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,comp.ai.philosophy on Thu Nov 12 16:04:39 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 3:54 PM, Python wrote:
    Le 12/11/2026 |a 20:43, olcott a |-crit :
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once? ? ?


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not infinite. >>>>> the infinite recursion only occurs if HHH doesn't break the
    invariant of letting the simulation run, but HHH does break that
    invariant, so invalidating the induction requires to prove infinite >>>>> recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the
    decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.

    Peter,

    -a-a "That is not even what those English words mean."

    For once, you have a point.

    Your sentence does NOT say that aborting the simulation automatically invalidates the decision.

    It says:

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

    Fine.

    A simulator MAY abort an execution after correctly establishing that it would otherwise run forever.

    NOBODY NEEDS TO DISPUTE THAT.

    But now comes the part you keep conveniently ignoring:

    -a-a "H CORRECTLY DETERMINES"

    HOW?


    I already explained the details of this to you too many times.
    It seems that you have lost interest in an honest dialogue
    weeks ago. You have been in full rebuttal mode ever since.

    Your simulator observes a finite sequence of execution steps.

    It detects recursion.

    It aborts.

    And you declare that the computation would never have terminated.

    WHERE IS THE PROOF OF THAT LAST STEP?

    The fact that the simulation was faithful UP TO THE ABORT does not
    establish that its prediction about the infinite future was correct.

    Nor does the fact that Sipser may have accepted your conditional statement.

    A conditional statement does not establish its own premise.

    "If H correctly determines nontermination" is perfectly compatible with
    the possibility that YOUR H does NOT correctly determine nontermination.

    You wrote those words.

    You say Sipser approved them.

    VERY WELL.

    NOW PROVE THAT YOUR PROGRAM SATISFIES THEM.

    And please, Peter, don't answer by explaining the operational semantics
    of C for the thousandth time.

    WE AGREE ABOUT FAITHFUL SIMULATION.

    THE QUESTION IS THE CORRECTNESS OF YOUR NONTERMINATION DECISION.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 22:07:19 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "The behavior of H(D) is outside of the scope
    of Turing computation when D calls H(D)"

    NO, PETER.

    THAT IS PRECISELY WHAT YOU HAVE TO PROVE.

    A program calling another program which, in turn, calls the first program
    is perfectly expressible within Turing computation.

    Recursion is computable.

    Self-reference is computable.

    Simulation is computable.

    NONE OF THESE IS OUTSIDE THE TURING MODEL.

    What is impossible is a TOTAL, CORRECT algorithm deciding whether EVERY arbitrary computation halts.

    And the diagonal construction demonstrates exactly WHY.

    You assume that H is such an algorithm.

    You construct D using H.

    You derive a contradiction.

    Therefore YOUR ASSUMPTION WAS FALSE.

    THAT IS HOW A PROOF BY CONTRADICTION WORKS.

    You cannot escape the contradiction by declaring that the very case
    exposing it is "outside the scope of Turing computation".

    That would simply mean your alleged universal decider does not handle
    every computable input.

    WHICH IS EXACTLY WHAT THE HALTING THEOREM SAYS.

    And your toaster analogy is ridiculous.

    A toaster cannot inflate tires because it lacks the necessary physical mechanism.

    A Turing machine can perfectly well represent and simulate recursive
    program calls.

    What it cannot do is compute a total, correct halting predicate for all programs.

    YOU ARE CONFUSING EXPRESSIBILITY WITH DECIDABILITY.

    After 22 years, THAT is your "bottom line"?


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 22:08:01 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "I already explained the details of this
    to you too many times."

    NO.

    You have explained HOW your simulator detects recursion.

    You have NOT established that the detected recursion can NEVER terminate.

    THOSE ARE TWO DIFFERENT THINGS.

    "You have been in full rebuttal mode ever since."

    OF COURSE I HAVE.

    You claim to have found a fundamental error in one of the most elementary theorems of computability theory.

    WHAT DID YOU EXPECT?

    Applause?

    A standing ovation?

    A reviewer who politely agrees without checking your reasoning?

    FOR FUCK'S SAKE, PETER.

    A proof is supposed to withstand rebuttal.

    And your complaint about my attitude does not establish a single
    mathematical fact.

    So here is the question, once again:

    WHAT EXACTLY GUARANTEES THAT THE RECURSION DETECTED BY YOUR HHH CAN NEVER TERMINATE?

    Not that recursion has begun.

    Not that your simulator has aborted it.

    Not that you have explained your code a thousand times.

    WHAT PROVES THAT IT WOULD CONTINUE FOREVER?

    If you have already demonstrated this, reproduce the decisive argument.

    ONE POINT.

    ONE PROOF.

    NO EXCUSES.


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

    On 11/12/2026 4:07 PM, Python wrote:
    Peter,

    -a-a "The behavior of H(D) is outside of the scope
    -a-a-a of Turing computation when D calls H(D)"

    NO, PETER.

    THAT IS PRECISELY WHAT YOU HAVE TO PROVE.


    I have but you just don't care enough to pay
    attention to the details.

    A program calling another program which, in turn, calls the first
    program is perfectly expressible within Turing computation.

    Recursion is computable.

    Self-reference is computable.

    Simulation is computable.

    NONE OF THESE IS OUTSIDE THE TURING MODEL.

    What is impossible is a TOTAL, CORRECT algorithm deciding whether EVERY arbitrary computation halts.

    And the diagonal construction demonstrates exactly WHY.

    You assume that H is such an algorithm.

    You construct D using H.

    You derive a contradiction.

    Therefore YOUR ASSUMPTION WAS FALSE.

    THAT IS HOW A PROOF BY CONTRADICTION WORKS.

    You cannot escape the contradiction by declaring that the very case
    exposing it is "outside the scope of Turing computation".

    That would simply mean your alleged universal decider does not handle
    every computable input.

    WHICH IS EXACTLY WHAT THE HALTING THEOREM SAYS.

    And your toaster analogy is ridiculous.

    A toaster cannot inflate tires because it lacks the necessary physical mechanism.

    A Turing machine can perfectly well represent and simulate recursive
    program calls.

    What it cannot do is compute a total, correct halting predicate for all programs.

    YOU ARE CONFUSING EXPRESSIBILITY WITH DECIDABILITY.

    After 22 years, THAT is your "bottom line"?
    --
    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,comp.ai.philosophy on Thu Nov 12 16:17:53 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 4:08 PM, Python wrote:
    Peter,

    -a-a "I already explained the details of this
    -a-a-a to you too many times."

    NO.

    You have explained HOW your simulator detects recursion.

    You have NOT established that the detected recursion can NEVER terminate.


    There does not exist any implementation of C function HHH
    that ONLY simulates C function DD according to the operational
    semantics of C such that the simulated C function DD reaches
    its own simulated return statement in any N finite number of
    steps while DD is being simulated by HHH.

    THOSE ARE TWO DIFFERENT THINGS.

    -a-a "You have been in full rebuttal mode ever since."

    OF COURSE I HAVE.

    You claim to have found a fundamental error in one of the most
    elementary theorems of computability theory.

    WHAT DID YOU EXPECT?

    Applause?

    A standing ovation?

    A reviewer who politely agrees without checking your reasoning?

    FOR FUCK'S SAKE, PETER.

    A proof is supposed to withstand rebuttal.

    And your complaint about my attitude does not establish a single mathematical fact.

    So here is the question, once again:

    WHAT EXACTLY GUARANTEES THAT THE RECURSION DETECTED BY YOUR HHH CAN
    NEVER TERMINATE?

    Not that recursion has begun.

    Not that your simulator has aborted it.

    Not that you have explained your code a thousand times.

    WHAT PROVES THAT IT WOULD CONTINUE FOREVER?

    If you have already demonstrated this, reproduce the decisive argument.

    ONE POINT.

    ONE PROOF.

    NO EXCUSES.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 22:24:45 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "I have but you just don't care enough
    to pay attention to the details."

    Then identify the precise step in your proof establishing that H(D) is
    outside the scope of Turing computation.

    Because your claim is fundamentally confused.

    A Turing machine can simulate another Turing machine.

    That simulated machine can itself simulate another machine.

    And the process can continue recursively.

    THERE IS NOTHING NON-TURING-COMPUTABLE ABOUT THAT.

    If the resulting computation never terminates, the Turing machine simply
    runs forever.

    NONTERMINATION IS NOT THE SAME THING AS NONCOMPUTABILITY.

    This is the distinction you keep missing.

    The Halting Theorem does NOT say that the diagonal program cannot be constructed or executed.

    It says that no total computable function can correctly decide the halting behavior of EVERY program, including the diagonal one.

    If H(D) fails to return, H is not total.

    If H(D) returns an incorrect answer, H is not correct.

    Either way, the hypothetical universal halting decider does not exist.

    THAT IS THE THEOREM.

    And declaring that the troublesome computation is "outside the scope of
    Turing computation" merely evades the contradiction by restricting the
    domain.

    It does not refute anything.

    So please stop telling me that I haven't paid attention.

    I have identified a precise mathematical distinction.

    YOU HAVE NOT ANSWERED IT.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 22:25:32 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    You have added yet another qualification:

    "while DD is being simulated by HHH."

    And you STILL haven't answered the question.

    There are TWO distinct propositions:

    (A) DD does not reach its return statement during the finite portion of
    the simulation that HHH actually performs.

    (B) DD would NEVER reach its return statement if the simulation continued indefinitely without being aborted.

    (A) DOES NOT IMPLY (B).

    A program that terminates after 1,000 steps has not reached its return statement during its first 100 steps.

    If your simulator aborts after 100 steps, that observation tells you
    NOTHING about whether the program would terminate at step 1,000.

    Now, your revised statement refers to what happens "while DD is being simulated by HHH".

    Does that mean the ACTUAL, FINITE simulation before HHH aborts?

    Or does it mean EVERY FINITE PREFIX of a hypothetical simulation that is
    NEVER aborted?

    THESE ARE NOT THE SAME CLAIM.

    If you mean the former, your statement does not establish nontermination.

    If you mean the latter, you are asserting precisely the infinite behavior
    you are supposed to prove.

    And if you mean something else, DEFINE IT.

    FOR FUCK'S SAKE, PETER.

    You cannot establish that a computation NEVER terminates merely by
    observing that it HAS NOT terminated before you stopped watching.

    ONE QUESTION:

    WHAT JUSTIFIES THE TRANSITION FROM (A) TO (B)?

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 17:19:52 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 4:24 PM, Python wrote:
    Peter,

    -a-a "I have but you just don't care enough
    -a-a-a to pay attention to the details."

    Then identify the precise step in your proof establishing that H(D) is outside the scope of Turing computation.


    Its a bunch of subtle steps.

    Because your claim is fundamentally confused.

    A Turing machine can simulate another Turing machine.

    That simulated machine can itself simulate another machine.

    And the process can continue recursively.

    THERE IS NOTHING NON-TURING-COMPUTABLE ABOUT THAT.

    If the resulting computation never terminates, the Turing machine simply runs forever.

    NONTERMINATION IS NOT THE SAME THING AS NONCOMPUTABILITY.

    This is the distinction you keep missing.

    The Halting Theorem does NOT say that the diagonal program cannot be constructed or executed.

    It says that no total computable function can correctly decide the
    halting behavior of EVERY program, including the diagonal one.

    If H(D) fails to return, H is not total.

    If H(D) returns an incorrect answer, H is not correct.

    Either way, the hypothetical universal halting decider does not exist.

    THAT IS THE THEOREM.

    And declaring that the troublesome computation is "outside the scope of Turing computation" merely evades the contradiction by restricting the domain.

    It does not refute anything.

    So please stop telling me that I haven't paid attention.

    I have identified a precise mathematical distinction.

    YOU HAVE NOT ANSWERED IT.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 23:23:01 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Its a bunch of subtle steps."

    No, Peter.

    It's a bunch of delusional evasions and confusions. In other words : a
    bunch of bullshit.

    And after 22 years, you still cannot identify a single invalid inference
    in the standard proof.

    You keep claiming that the diagonal computation is outside the scope of
    Turing computation.

    WHY?

    Because of recursion?

    Because of self-reference?

    Because your simulator aborts?

    NONE OF THESE ESTABLISHES YOUR CLAIM.

    You don't need to explain everything at once.

    START WITH THE FIRST STEP.

    State its premises.

    State its conclusion.

    Show how the conclusion follows.

    Then proceed to the next step.

    THAT IS HOW A MATHEMATICAL PROOF WORKS.

    "There's a bunch of subtle steps" is not a proof.

    It's an excuse for not providing one.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 17:40:21 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 5:23 PM, Python wrote:
    Peter,

    -a-a "Its a bunch of subtle steps."

    No, Peter.

    It's a bunch of delusional evasions and confusions. In other words : a
    bunch of bullshit.

    And after 22 years, you still cannot identify a single invalid inference
    in the standard proof.

    You keep claiming that the diagonal computation is outside the scope of Turing computation.

    WHY?

    Because of recursion?


    DD cannot even reach its own paradoxical code.
    You know that. You know that no one besides
    me ever noticed that.

    Because of self-reference?

    Because your simulator aborts?

    NONE OF THESE ESTABLISHES YOUR CLAIM.

    You don't need to explain everything at once.

    START WITH THE FIRST STEP.

    State its premises.

    State its conclusion.

    Show how the conclusion follows.

    Then proceed to the next step.

    THAT IS HOW A MATHEMATICAL PROOF WORKS.

    "There's a bunch of subtle steps" is not a proof.

    It's an excuse for not providing one.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 23:56:32 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "DD cannot even reach its own paradoxical code."

    WRONG.

    The "paradoxical code" is not some mysterious instruction that DD must
    reach after an infinite number of recursive calls.

    It is the conditional statement:

    if (Halt_Status)
    HERE: goto HERE;
    return Halt_Status;

    And whether DD reaches that statement depends on whether HHH(DD) returns.

    NOW PAY ATTENTION.

    The standard Halting Theorem assumes that H is a TOTAL, CORRECT halting decider.

    TOTAL MEANS IT RETURNS AN ANSWER.

    Therefore, under that assumption, DD DOES reach its conditional statement.

    And then:

    If H says DD halts, DD loops.

    If H says DD does not halt, DD returns.

    CONTRADICTION.

    If instead H never returns because it gets trapped in recursive
    simulation, then H IS NOT TOTAL.

    WHICH ALSO DISQUALIFIES IT AS A UNIVERSAL HALTING DECIDER.

    Either way, the theorem stands.

    Your alleged discovery that DD cannot reach its conditional statement
    merely describes what happens when you replace the hypothetical total
    decider with a particular implementation that fails to return.

    YOU HAVE NOT FOUND AN ERROR IN THE PROOF.

    YOU HAVE DROPPED ONE OF ITS HYPOTHESES.

    And after 22 years, you still confuse the consequences of an assumption
    with the behavior of your own program.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 18:24:44 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 5:56 PM, Python wrote:
    Peter,

    -a-a "DD cannot even reach its own paradoxical code."

    WRONG.

    The "paradoxical code" is not some mysterious instruction that DD must
    reach after an infinite number of recursive calls.

    It is the conditional statement:

    -a-a if (Halt_Status)
    -a-a-a-a-a-a HERE: goto HERE;
    -a-a return Halt_Status;

    And whether DD reaches that statement depends on whether HHH(DD) returns.

    NOW PAY ATTENTION.

    The standard Halting Theorem assumes that H is a TOTAL, CORRECT halting decider.

    TOTAL MEANS IT RETURNS AN ANSWER.

    Therefore, under that assumption, DD DOES reach its conditional statement.


    Yet when H applies the most relevant finite string
    transformation / inference steps to its static finite
    string D, then this input D cannot reach that code.

    The way that the HP gets around all that is they simply
    make sure to totally ignore the limited categories of
    finite string transformations that can possibly see the
    behavior that input D specifies.

    And then:

    If H says DD halts, DD loops.

    If H says DD does not halt, DD returns.

    CONTRADICTION.

    If instead H never returns because it gets trapped in recursive
    simulation, then H IS NOT TOTAL.

    WHICH ALSO DISQUALIFIES IT AS A UNIVERSAL HALTING DECIDER.

    Either way, the theorem stands.

    Your alleged discovery that DD cannot reach its conditional statement
    merely describes what happens when you replace the hypothetical total decider with a particular implementation that fails to return.

    YOU HAVE NOT FOUND AN ERROR IN THE PROOF.

    YOU HAVE DROPPED ONE OF ITS HYPOTHESES.

    And after 22 years, you still confuse the consequences of an assumption
    with the behavior of your own program.
    --
    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 17:30:59 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-12 11:52, olcott wrote:
    On 11/12/2026 12:11 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 10:11, polcott wrote:
    On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 21:52, olcott wrote:
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to >>>>>>>>>> testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>>
    If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a pattern >>>>>>>>>> of infinite recursion, but then it also wouldn't be the HHH >>>>>>>>>> which he claims to be a potential halt decider, so the
    argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation >>>>>>>>> All Turing equivalent computations can be reduced to applying >>>>>>>>> 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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY >>>>>>>> in your new formulation. I'd offered my interpretation, but you >>>>>>>> neither confirm nor deny it. How does repeating three things
    verbatim from your previous posts offer any sort of clarification? >>>>>>>>
    Communication is not your strong point. Maybe try working on
    that by actually providing the requested clarification. What
    does the word ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit >>>>>> of doing this -- people ask questions or for clarifications and
    you simply repost stuff we've all already read which doesn't
    actually answer anything. If what you posted wasn't clear the
    first time, repeating it isn't going to provide any clarification. >>>>>>
    You'd been asked to clarify what you thought the inclusion of the >>>>>> word 'ONLY' in your new wording accomplishes. I'd given my best
    guess as to what you meant by this [still present in the above
    quoted text], but your reply above leaves me none the wiser about >>>>>> whether I was on the right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Now you're just being an ass. If it were obvious I wouldn't be
    asking for clarification.

    Above I wrote that I thought by ONLY simulates DD you meant
    simulates as opposed to simulates with the possibility of aborting DD. >>>>

    While being simulated

    That doesn't clarify anything. It's not even a complete sentence. It
    certainly makes no mention of what you mean by ONLY.

    I'm asking for a simple confirmation or denial that this is what you
    meant.

    Is the above really too much to ask?

    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.


    -aThere does not exist any implementation of C function
    -aHHH that ONLY simulates C function DD according to the
    -aoperational semantics of C such that the simulated C
    -afunction DD reaches its own simulated return statement
    -ain any N finite number of steps
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.


    It doesn't matter how many times you repeat that last bit, it still
    doesn't answer my question.

    You changed the wording of your claim to include the word ONLY, but it
    was unclear what the intent was. When you say HHH ONLY simulates DD..
    you're presumably excluding some other case such as the case where HHH
    does something in addition to simulating DD, or simulates something in addition to DD. I'd interpreted it to mean that 'HHH ONLY simulates DD
    and does not abort it'. I'd asked if my interpretation was on the right
    track. That's a simply yes/no question. I've already ready your above
    passage many times and it does not provide answers to this question.

    So can you kindly simply answer with a yes or a no. If you want to
    include additional explanation that's fine, but please include a yes or
    a no.

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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 00:32:51 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "when H applies the most relevant finite string
    transformation / inference steps to its static
    finite string D, then this input D cannot reach
    that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or
    simulating D.

    It assumes that H is a TOTAL, CORRECT COMPUTABLE DECIDER.

    HOW H WORKS IS IRRELEVANT.

    It may simulate instructions.

    It may analyze source code.

    It may apply finite string rewriting rules.

    It may use whatever computable inference procedure you like.

    THE DIAGONAL ARGUMENT STILL APPLIES.

    Suppose your finite string transformations correctly determine whether
    every arbitrary program halts.

    Then they constitute a halting decision algorithm.

    Call it H.

    Construct D to do the opposite of H's prediction about D.

    And the contradiction follows.

    If your transformations cannot produce a correct answer for this D, then
    they are NOT a universal halting decider.

    THAT IS EXACTLY WHAT THE THEOREM PREDICTS.

    "The way that the HP gets around all that
    is they simply make sure to totally ignore
    the limited categories of finite string
    transformations..."

    NONSENSE.

    The theorem does not ignore those transformations.

    IT INCLUDES THEM.

    Every effective finite string rewriting procedure is subject to the same computability limits.

    You cannot escape diagonalization by changing the implementation language
    of H.

    So here is ONE precise question:

    Do your finite string transformation rules constitute a TOTAL, CORRECT algorithm for deciding whether ANY arbitrary program halts?

    YES OR NO?

    If YES, diagonalization applies to YOUR algorithm.

    If NO, you have not contradicted the Halting Theorem.

    And if you refuse to answer, stop pretending that the theorem somehow overlooked your favorite implementation technique.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 18:35:05 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 6:30 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 11:52, olcott wrote:
    On 11/12/2026 12:11 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 10:11, polcott wrote:
    On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 21:52, olcott wrote:
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to >>>>>>>>>>> testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>>>
    If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a pattern >>>>>>>>>>> of infinite recursion, but then it also wouldn't be the HHH >>>>>>>>>>> which he claims to be a potential halt decider, so the
    argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation >>>>>>>>>> All Turing equivalent computations can be reduced to applying >>>>>>>>>> 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 string inputs is outside of the
    domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word ONLY >>>>>>>>> in your new formulation. I'd offered my interpretation, but you >>>>>>>>> neither confirm nor deny it. How does repeating three things >>>>>>>>> verbatim from your previous posts offer any sort of clarification? >>>>>>>>>
    Communication is not your strong point. Maybe try working on >>>>>>>>> that by actually providing the requested clarification. What >>>>>>>>> does the word ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification
    of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a habit >>>>>>> of doing this -- people ask questions or for clarifications and >>>>>>> you simply repost stuff we've all already read which doesn't
    actually answer anything. If what you posted wasn't clear the
    first time, repeating it isn't going to provide any clarification. >>>>>>>
    You'd been asked to clarify what you thought the inclusion of the >>>>>>> word 'ONLY' in your new wording accomplishes. I'd given my best >>>>>>> guess as to what you meant by this [still present in the above
    quoted text], but your reply above leaves me none the wiser about >>>>>>> whether I was on the right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Now you're just being an ass. If it were obvious I wouldn't be
    asking for clarification.

    Above I wrote that I thought by ONLY simulates DD you meant
    simulates as opposed to simulates with the possibility of aborting DD. >>>>>

    While being simulated

    That doesn't clarify anything. It's not even a complete sentence. It
    certainly makes no mention of what you mean by ONLY.

    I'm asking for a simple confirmation or denial that this is what
    you meant.

    Is the above really too much to ask?

    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.


    -a-aThere does not exist any implementation of C function
    -a-aHHH that ONLY simulates C function DD according to the
    -a-aoperational semantics of C such that the simulated C
    -a-afunction DD reaches its own simulated return statement
    -a-ain any N finite number of steps
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.


    It doesn't matter how many times you repeat that last bit, it still
    doesn't answer my question.

    You changed the wording of your claim to include the word ONLY, but it
    was unclear what the intent was.

    Then you simply did not pay close enough attention
    to the attempted rebuttal by Python.

    When you say HHH ONLY simulates DD..
    you're presumably excluding some other case such as the case where HHH
    does something in addition to simulating DD, or simulates something in addition to DD. I'd interpreted it to mean that 'HHH ONLY simulates DD
    and does not abort it'. I'd asked if my interpretation was on the right track. That's a simply yes/no question. I've already ready your above passage many times and it does not provide answers to this question.

    So can you kindly simply answer with a yes or a no. If you want to
    include additional explanation that's fine, but please include a yes or
    a no.

    Andr|-

    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 00:38:52 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Then you simply did not pay close enough
    attention to the attempted rebuttal by Python."

    NO, PETER.

    ANDR|e IS PAYING ATTENTION.

    YOU ARE NOT.

    Andr|- has understood perfectly well WHY you added "ONLY".

    You wanted to exclude my counterexample.

    WE GET IT.

    But he is asking WHAT THE WORD EXCLUDES.

    THAT IS A DIFFERENT QUESTION.

    He even offered you a precise interpretation:

    "HHH ONLY simulates DD and does not abort it."

    And asked you to confirm or deny it.

    YES OR NO.

    Instead, you repeat:

    "while DD is being simulated by HHH"

    EIGHT TIMES!

    FOR FUCK'S SAKE!

    Repeating a sentence eight times does not define an undefined term.

    And accusing someone of not paying attention does not answer their
    question.

    Andr|- has demonstrated considerable patience in trying to extract a
    simple clarification from you.

    You, meanwhile, have demonstrated an extraordinary ability to avoid giving one.

    So here is your opportunity.

    Does "ONLY simulates" exclude aborting the simulation?

    YES OR NO?

    If you cannot answer even THAT, perhaps the problem is not that your
    reviewers lack intelligence or attention.

    Perhaps the problem is that YOU DON'T KNOW WHAT YOUR OWN CLAIM MEANS.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 18:48:09 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a "when H applies the most relevant finite string
    -a-a-a transformation / inference steps to its static
    -a-a-a finite string D, then this input D cannot reach
    -a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or
    simulating D.


    strcmp() is limited to those operations that
    compare strings.

    Halt deciders are limited to those operations
    that can see behavior.

    It assumes that H is a TOTAL, CORRECT COMPUTABLE DECIDER.

    HOW H WORKS IS IRRELEVANT.

    It may simulate instructions.

    It may analyze source code.

    It may apply finite string rewriting rules.

    It may use whatever computable inference procedure you like.

    THE DIAGONAL ARGUMENT STILL APPLIES.

    Suppose your finite string transformations correctly determine whether
    every arbitrary program halts.

    Then they constitute a halting decision algorithm.

    Call it H.

    Construct D to do the opposite of H's prediction about D.

    And the contradiction follows.

    If your transformations cannot produce a correct answer for this D, then they are NOT a universal halting decider.

    THAT IS EXACTLY WHAT THE THEOREM PREDICTS.

    -a-a "The way that the HP gets around all that
    -a-a-a is they simply make sure to totally ignore
    -a-a-a the limited categories of finite string
    -a-a-a transformations..."

    NONSENSE.

    The theorem does not ignore those transformations.

    IT INCLUDES THEM.

    Every effective finite string rewriting procedure is subject to the same computability limits.

    You cannot escape diagonalization by changing the implementation
    language of H.

    So here is ONE precise question:

    Do your finite string transformation rules constitute a TOTAL, CORRECT algorithm for deciding whether ANY arbitrary program halts?

    YES OR NO?

    If YES, diagonalization applies to YOUR algorithm.

    If NO, you have not contradicted the Halting Theorem.

    And if you refuse to answer, stop pretending that the theorem somehow overlooked your favorite implementation technique.
    --
    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,comp.ai.philosophy on Thu Nov 12 18:48:46 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 6:38 PM, Python wrote:
    Peter,

    -a-a "Then you simply did not pay close enough
    -a-a-a attention to the attempted rebuttal by Python."

    NO, PETER.

    ANDR|e IS PAYING ATTENTION.

    YOU ARE NOT.

    Andr|- has understood perfectly well WHY you added "ONLY".


    Then he was dishonest for asking why.

    You wanted to exclude my counterexample.

    WE GET IT.

    But he is asking WHAT THE WORD EXCLUDES.

    THAT IS A DIFFERENT QUESTION.

    He even offered you a precise interpretation:

    -a-a "HHH ONLY simulates DD and does not abort it."

    And asked you to confirm or deny it.

    YES OR NO.

    Instead, you repeat:

    -a-a "while DD is being simulated by HHH"

    EIGHT TIMES!

    FOR FUCK'S SAKE!

    Repeating a sentence eight times does not define an undefined term.

    And accusing someone of not paying attention does not answer their
    question.

    Andr|- has demonstrated considerable patience in trying to extract a
    simple clarification from you.

    You, meanwhile, have demonstrated an extraordinary ability to avoid
    giving one.

    So here is your opportunity.

    Does "ONLY simulates" exclude aborting the simulation?

    YES OR NO?

    If you cannot answer even THAT, perhaps the problem is not that your reviewers lack intelligence or attention.

    Perhaps the problem is that YOU DON'T KNOW WHAT YOUR OWN CLAIM MEANS.
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 16:49:03 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 1:53 PM, dart200 wrote:
    On 11/12/26 12:49 PM, olcott wrote:
    On 11/12/2026 2:26 PM, dart200 wrote:
    On 11/12/26 11:43 AM, olcott wrote:
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions >>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>>> invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical
    based on the invariant that HHH not cut DD simulation's short
    after the initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not
    infinite. the infinite recursion only occurs if HHH doesn't break >>>>>>> the invariant of letting the simulation run, but HHH does break >>>>>>> that invariant, so invalidating the induction requires to prove >>>>>>> infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the
    decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.


    ok so what does "unless aborted then" mean polcott?


    All non-halting behavior such as an infinite
    loop will continue to run unless aborted.


    and what does HHH ultimately do to the simulation of DD?


    polcott u didn't answer this...
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 18:51:49 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 6:49 PM, dart200 wrote:
    On 11/12/26 1:53 PM, dart200 wrote:
    On 11/12/26 12:49 PM, olcott wrote:
    On 11/12/2026 2:26 PM, dart200 wrote:
    On 11/12/26 11:43 AM, olcott wrote:
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>>>> invariant that HHH not cut DD simulation's short after the >>>>>>>>>> recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical
    based on the invariant that HHH not cut DD simulation's short >>>>>>>> after the initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not
    infinite. the infinite recursion only occurs if HHH doesn't
    break the invariant of letting the simulation run, but HHH does >>>>>>>> break that invariant, so invalidating the induction requires to >>>>>>>> prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the
    decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.


    ok so what does "unless aborted then" mean polcott?


    All non-halting behavior such as an infinite
    loop will continue to run unless aborted.


    and what does HHH ultimately do to the simulation of DD?


    polcott u didn't answer this...


    Makes bologna sandwiches?
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 00:57:15 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "strcmp() is limited to those operations
    that compare strings."

    WRONG ANALOGY.

    strcmp() is specified by WHAT IT COMPUTES, not by some arbitrary
    restriction on HOW it must compute it.

    An implementation may compare bytes sequentially, use word-sized
    operations, vector instructions, or any other technique preserving the specified result.

    NOW APPLY THE SAME PRINCIPLE TO HALTING DECIDERS.

    A halting decider is specified by WHAT IT COMPUTES:

    H(P, x) = 1 if P(x) halts
    H(P, x) = 0 otherwise

    It is NOT defined by HOW it obtains that answer.

    "Halt deciders are limited to those
    operations that can see behavior."

    WHAT THE FUCK DOES "SEE BEHAVIOR" MEAN?

    Static analysis can establish the behavior of certain programs without executing them.

    Symbolic execution can reason about paths that have never actually been executed.

    Mathematical proofs can establish termination or nontermination without simulating every step.

    NONE OF THESE IS EXCLUDED.

    The Halting Theorem concerns ALL computable methods for producing a total, correct answer.

    Not merely the methods Peter Olcott considers sufficiently
    "behavior-seeing".

    And your analogy actually exposes the problem.

    If you define a "halting decider" to mean ONLY a particular kind of
    simulator, then you are no longer addressing the general Halting Problem.

    You have restricted the implementation, not refuted the theorem.

    So answer the question you avoided:

    CAN YOUR METHOD CORRECTLY DECIDE HALTING FOR EVERY ARBITRARY PROGRAM AND INPUT?

    YES OR NO?

    If YES, diagonalization applies.

    If NO, your method is not a universal halting decider.

    No amount of hand-waving about "seeing behavior" changes that.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 00:57:49 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Then he was dishonest for asking why."

    FOR FUCK'S SAKE.

    Andr|- did NOT ask why you added "ONLY".

    He asked WHAT IT MEANS.

    He even proposed an explicit interpretation and requested a YES or NO
    answer.

    You have now repeatedly confused:

    WHY you introduced a restriction

    with:

    WHAT that restriction actually excludes.

    THESE ARE NOT THE SAME QUESTION.

    And instead of answering, you accuse Andr|- of dishonesty.

    Let's make this painfully simple.

    You added "ONLY" to exclude my counterexample.

    FINE.

    WHAT PROPERTY OF MY COUNTEREXAMPLE DOES "ONLY" EXCLUDE?

    State that property precisely.

    If you cannot, your new restriction is meaningless.

    If you can, explain it instead of insulting people who ask.

    Andr|- is not being dishonest.

    He is asking you to specify your own claim.

    THAT IS WHAT HONEST MATHEMATICAL DISCUSSION REQUIRES.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 17:03:25 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 4:51 PM, olcott wrote:
    On 11/12/2026 6:49 PM, dart200 wrote:
    On 11/12/26 1:53 PM, dart200 wrote:
    On 11/12/26 12:49 PM, olcott wrote:
    On 11/12/2026 2:26 PM, dart200 wrote:
    On 11/12/26 11:43 AM, olcott wrote:
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are >>>>>>>>>>>>>>> NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years. >>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>> words to not conform to their false assumptions.

    I can very much better show that these assumptions >>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>> the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>
    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on >>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>> the recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>> based on the invariant that HHH not cut DD simulation's short >>>>>>>>> after the initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not
    infinite. the infinite recursion only occurs if HHH doesn't >>>>>>>>> break the invariant of letting the simulation run, but HHH does >>>>>>>>> break that invariant, so invalidating the induction requires to >>>>>>>>> prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the
    decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.


    ok so what does "unless aborted then" mean polcott?


    All non-halting behavior such as an infinite
    loop will continue to run unless aborted.


    and what does HHH ultimately do to the simulation of DD?


    polcott u didn't answer this...


    Makes bologna sandwiches?


    ur claiming that HHH makes bologna sandwiches with the simulation of DD?

    are you just a fking troll bro?
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 19:04:44 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 6:57 PM, Python wrote:
    Peter,

    -a-a "strcmp() is limited to those operations
    -a-a-a that compare strings."

    WRONG ANALOGY.

    strcmp() is specified by WHAT IT COMPUTES, not by some arbitrary
    restriction on HOW it must compute it.

    An implementation may compare bytes sequentially, use word-sized
    operations, vector instructions, or any other technique preserving the specified result.

    NOW APPLY THE SAME PRINCIPLE TO HALTING DECIDERS.

    A halting decider is specified by WHAT IT COMPUTES:

    -a-a H(P, x) = 1 if P(x) halts
    -a-a H(P, x) = 0 otherwise

    It is NOT defined by HOW it obtains that answer.

    -a-a "Halt deciders are limited to those
    -a-a-a operations that can see behavior."

    WHAT THE FUCK DOES "SEE BEHAVIOR" MEAN?


    A halt decider must be able to correctly determine
    the exact sequence of steps that an input finite
    string specifies.

    I am only going to address one single point with
    you one at a time. I will always erase everything
    after your first question.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 01:12:45 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "A halt decider must be able to correctly determine
    the exact sequence of steps that an input finite
    string specifies."

    NO, PETER.

    THAT IS NOT THE DEFINITION OF A HALTING DECIDER.

    A halting decider must determine WHETHER a computation terminates.

    NOT its exact sequence of execution steps.

    For example, consider:

    int f(void)
    {
    while (1) {}
    }

    We can prove that this function never terminates WITHOUT enumerating its infinite execution trace.

    Likewise, we can prove that many terminating programs terminate without computing their complete execution traces.

    You are confusing TWO DIFFERENT PROBLEMS:

    1. Determining whether a computation terminates.

    2. Determining its exact execution trace.

    THEY ARE NOT THE SAME PROBLEM.

    And the Halting Theorem concerns the FIRST.

    You are free to invent a restricted class of algorithms that must
    reconstruct execution traces.

    But proving limitations of that restricted class does NOT establish limitations of all possible halting deciders.

    Nor does it invalidate the standard diagonal proof.

    So here is my ONE question:

    WHERE, in the mathematical definition of the Halting Problem, is a decider required to determine the exact sequence of execution steps?

    Please provide the definition.

    NOT YOUR PERSONAL REDEFINITION.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 19:26:25 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 7:12 PM, Python wrote:
    Peter,

    -a-a "A halt decider must be able to correctly determine
    -a-a-a the exact sequence of steps that an input finite
    -a-a-a string specifies."

    NO, PETER.

    THAT IS NOT THE DEFINITION OF A HALTING DECIDER.

    A halting decider must determine WHETHER a computation terminates.

    NOT its exact sequence of execution steps.

    For example, consider:

    -a-a int f(void)
    -a-a {
    -a-a-a-a-a-a while (1) {}
    -a-a }

    We can prove that this function never terminates WITHOUT enumerating its infinite execution trace.

    Likewise, we can prove that many terminating programs terminate without computing their complete execution traces.

    You are confusing TWO DIFFERENT PROBLEMS:

    1. Determining whether a computation terminates.

    2. Determining its exact execution trace.

    THEY ARE NOT THE SAME PROBLEM.


    We must determine its exact execution up
    to the point where we can determine whether
    or not it terminates.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 01:27:59 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "We must determine its exact execution up
    to the point where we can determine whether
    or not it terminates."

    NO.

    You have merely moved the goalposts.

    First you required the exact sequence of execution steps.

    Now you require it only "up to the point" where termination can be
    determined.

    But that point can be reached WITHOUT EXECUTING OR SIMULATING A SINGLE
    STEP.

    Consider:

    int f(unsigned n)
    {
    while (n > 0)
    --n;
    return 0;
    }

    We can prove that f terminates for every possible value of n simply
    because n is a nonnegative integer that strictly decreases on each
    iteration.

    NO EXECUTION TRACE IS REQUIRED.

    NO SIMULATION IS REQUIRED.

    NO ENUMERATION OF STEPS IS REQUIRED.

    And for:

    void g(void)
    {
    for (;;) {}
    }

    We can prove nontermination directly from the program structure.

    Again, without reconstructing an infinite execution trace.

    Your claim is not a theorem of computability.

    It is an arbitrary restriction you keep trying to impose on the definition
    of a halting decider.

    So ONE question:

    WHY must a halting decider reconstruct any execution steps when a
    mathematical proof already establishes the answer?

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

    On 11/12/2026 7:27 PM, Python wrote:
    Peter,

    -a-a "We must determine its exact execution up
    -a-a-a to the point where we can determine whether
    -a-a-a or not it terminates."

    NO.

    You have merely moved the goalposts.

    First you required the exact sequence of execution steps.

    Now you require it only "up to the point" where termination can be determined.

    But that point can be reached WITHOUT EXECUTING OR SIMULATING A SINGLE
    STEP.

    Consider:

    -a-a int f(unsigned n)
    -a-a {
    -a-a-a-a-a-a while (n > 0)
    -a-a-a-a-a-a-a-a-a-a --n;
    -a-a-a-a-a-a return 0;
    -a-a }

    We can prove that f terminates for every possible value of n simply
    because n is a nonnegative integer that strictly decreases on each iteration.

    NO EXECUTION TRACE IS REQUIRED.

    NO SIMULATION IS REQUIRED.

    NO ENUMERATION OF STEPS IS REQUIRED.

    And for:

    -a-a void g(void)
    -a-a {
    -a-a-a-a-a-a for (;;) {}
    -a-a }

    We can prove nontermination directly from the program structure.

    Again, without reconstructing an infinite execution trace.


    I certainly did not mean all infinite of them.

    Your claim is not a theorem of computability.

    It is an arbitrary restriction you keep trying to impose on the
    definition of a halting decider.

    So ONE question:

    WHY must a halting decider reconstruct any execution steps when a mathematical proof already establishes the answer?

    Think in terms of a termination analyzer.
    AProVE: Non-Termination Witnesses for C Programs https://link.springer.com/chapter/10.1007/978-3-030-99527-0_21
    Does it automatically know the answer for any arbitrary input?
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 01:41:11 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "I certainly did not mean all infinite of them."

    Nobody said you did.

    The point is that determining termination does NOT require reconstructing
    an execution trace, finite or infinite.

    And now you bring up AProVE.

    EXCELLENT EXAMPLE.

    AProVE uses mathematical techniques to prove termination or nontermination
    for classes of programs.

    It does NOT need to simulate every execution step to establish its conclusions.

    "Does it automatically know the answer
    for any arbitrary input?"

    OF COURSE NOT.

    AND THAT IS PRECISELY THE POINT.

    AProVE is not a universal halting decider.

    For some inputs, it proves termination.

    For others, it proves nontermination.

    For still others, it cannot establish either result.

    THAT IS ENTIRELY CONSISTENT WITH THE HALTING THEOREM.

    You seem to believe that because no termination analyzer can solve every possible case, all termination analyzers must be restricted to
    reconstructing execution traces.

    THAT DOES NOT FOLLOW.

    And the fact that AProVE cannot decide every arbitrary case does not
    establish your claim that diagonal computations lie outside Turing computation.

    It establishes nothing of the sort.

    So let's return to the ONE question you keep avoiding:

    WHERE IS THE REQUIREMENT THAT A HALTING DECIDER MUST RECONSTRUCT EXECUTION STEPS, RATHER THAN USE ANY COMPUTABLE MATHEMATICAL ANALYSIS?

    A definition, Peter.

    Not another example of an analyzer that cannot solve the undecidable.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 19:48:32 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 7:41 PM, Python wrote:
    Peter,

    -a-a "I certainly did not mean all infinite of them."

    Nobody said you did.

    The point is that determining termination does NOT require
    reconstructing an execution trace, finite or infinite.

    And now you bring up AProVE.

    EXCELLENT EXAMPLE.

    AProVE uses mathematical techniques to prove termination or
    nontermination for classes of programs.

    It does NOT need to simulate every execution step to establish its conclusions.

    -a-a "Does it automatically know the answer
    -a-a-a for any arbitrary input?"

    OF COURSE NOT.

    AND THAT IS PRECISELY THE POINT.

    AProVE is not a universal halting decider.

    For some inputs, it proves termination.

    For others, it proves nontermination.

    For still others, it cannot establish either result.

    THAT IS ENTIRELY CONSISTENT WITH THE HALTING THEOREM.

    You seem to believe that because no termination analyzer can solve every possible case, all termination analyzers must be restricted to reconstructing execution traces.

    THAT DOES NOT FOLLOW.


    Every termination analyzer must always somehow
    determine the sequence of steps required to
    determine whether an input finite string specifies
    behavior that reaches a final state or not.

    For Turing computable functions this must always
    be consistent with D simulated by H.

    And the fact that AProVE cannot decide every arbitrary case does not establish your claim that diagonal computations lie outside Turing computation.

    It establishes nothing of the sort.

    So let's return to the ONE question you keep avoiding:

    WHERE IS THE REQUIREMENT THAT A HALTING DECIDER MUST RECONSTRUCT
    EXECUTION STEPS, RATHER THAN USE ANY COMPUTABLE MATHEMATICAL ANALYSIS?

    A definition, Peter.

    Not another example of an analyzer that cannot solve the undecidable.
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 18:40:33 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 5:03 PM, dart200 wrote:
    On 11/12/26 4:51 PM, olcott wrote:
    On 11/12/2026 6:49 PM, dart200 wrote:
    On 11/12/26 1:53 PM, dart200 wrote:
    On 11/12/26 12:49 PM, olcott wrote:
    On 11/12/2026 2:26 PM, dart200 wrote:
    On 11/12/26 11:43 AM, olcott wrote:
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are >>>>>>>>>>>>>>>> NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years. >>>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>>> words to not conform to their false assumptions. >>>>>>>>>>>>>>>
    I can very much better show that these assumptions >>>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>>>>> being wrong about something in regards to it, at least >>>>>>>>>>>>>> once???


    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>>> the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>>
    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on >>>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>>> the recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>>> based on the invariant that HHH not cut DD simulation's short >>>>>>>>>> after the initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not >>>>>>>>>> infinite. the infinite recursion only occurs if HHH doesn't >>>>>>>>>> break the invariant of letting the simulation run, but HHH >>>>>>>>>> does break that invariant, so invalidating the induction
    requires to prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the >>>>>>>> decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.


    ok so what does "unless aborted then" mean polcott?


    All non-halting behavior such as an infinite
    loop will continue to run unless aborted.


    and what does HHH ultimately do to the simulation of DD?


    polcott u didn't answer this...


    Makes bologna sandwiches?


    ur claiming that HHH makes bologna sandwiches with the simulation of DD?

    are you just a fking troll bro?


    seriously bro after over 2 decades ur reduced to this level of trolling???

    everyone knows DD halts

    everyone knows HHH violates the invariant that sipser directly pointed out

    ur not fooling anyone but urself dud
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 20:51:19 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 8:40 PM, dart200 wrote:
    On 11/12/26 5:03 PM, dart200 wrote:
    On 11/12/26 4:51 PM, olcott wrote:
    On 11/12/2026 6:49 PM, dart200 wrote:
    On 11/12/26 1:53 PM, dart200 wrote:
    On 11/12/26 12:49 PM, olcott wrote:
    On 11/12/2026 2:26 PM, dart200 wrote:
    On 11/12/26 11:43 AM, olcott wrote:
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are >>>>>>>>>>>>>>>>> NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years. >>>>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>>>> words to not conform to their false assumptions. >>>>>>>>>>>>>>>>
    I can very much better show that these assumptions >>>>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>>>>>> being wrong about something in regards to it, at least >>>>>>>>>>>>>>> once???


    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>>>> the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>>>
    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according >>>>>>>>>>>>>> to the operational semantics of the C programming
    language specifies recursive simulation does seems >>>>>>>>>>>>>> to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on >>>>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>>>> the recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>>>> based on the invariant that HHH not cut DD simulation's short >>>>>>>>>>> after the initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not >>>>>>>>>>> infinite. the infinite recursion only occurs if HHH doesn't >>>>>>>>>>> break the invariant of letting the simulation run, but HHH >>>>>>>>>>> does break that invariant, so invalidating the induction >>>>>>>>>>> requires to prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the >>>>>>>>> decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.


    ok so what does "unless aborted then" mean polcott?


    All non-halting behavior such as an infinite
    loop will continue to run unless aborted.


    and what does HHH ultimately do to the simulation of DD?


    polcott u didn't answer this...


    Makes bologna sandwiches?


    ur claiming that HHH makes bologna sandwiches with the simulation of DD?

    are you just a fking troll bro?


    seriously bro after over 2 decades ur reduced to this level of trolling???

    everyone knows DD halts

    everyone knows HHH violates the invariant that sipser directly pointed out


    You can't even pay attention to the meaning of words.

    ur not fooling anyone but urself dud

    --
    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 19:55:45 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-12 17:35, olcott wrote:
    On 11/12/2026 6:30 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 11:52, olcott wrote:
    On 11/12/2026 12:11 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 10:11, polcott wrote:
    On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 21:52, olcott wrote:
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to >>>>>>>>>>>> testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>>>>
    If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a pattern >>>>>>>>>>>> of infinite recursion, but then it also wouldn't be the HHH >>>>>>>>>>>> which he claims to be a potential halt decider, so the >>>>>>>>>>>> argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation >>>>>>>>>>> All Turing equivalent computations can be reduced to applying >>>>>>>>>>> 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 string inputs is outside of the >>>>>>>>>>> domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word >>>>>>>>>> ONLY in your new formulation. I'd offered my interpretation, >>>>>>>>>> but you neither confirm nor deny it. How does repeating three >>>>>>>>>> things verbatim from your previous posts offer any sort of >>>>>>>>>> clarification?

    Communication is not your strong point. Maybe try working on >>>>>>>>>> that by actually providing the requested clarification. What >>>>>>>>>> does the word ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification >>>>>>>>> of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a
    habit of doing this -- people ask questions or for
    clarifications and you simply repost stuff we've all already
    read which doesn't actually answer anything. If what you posted >>>>>>>> wasn't clear the first time, repeating it isn't going to provide >>>>>>>> any clarification.

    You'd been asked to clarify what you thought the inclusion of >>>>>>>> the word 'ONLY' in your new wording accomplishes. I'd given my >>>>>>>> best guess as to what you meant by this [still present in the >>>>>>>> above quoted text], but your reply above leaves me none the
    wiser about whether I was on the right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Now you're just being an ass. If it were obvious I wouldn't be
    asking for clarification.

    Above I wrote that I thought by ONLY simulates DD you meant
    simulates as opposed to simulates with the possibility of aborting >>>>>> DD.


    While being simulated

    That doesn't clarify anything. It's not even a complete sentence. It
    certainly makes no mention of what you mean by ONLY.

    I'm asking for a simple confirmation or denial that this is what
    you meant.

    Is the above really too much to ask?

    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.


    -a-aThere does not exist any implementation of C function
    -a-aHHH that ONLY simulates C function DD according to the
    -a-aoperational semantics of C such that the simulated C
    -a-afunction DD reaches its own simulated return statement
    -a-ain any N finite number of steps
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.


    It doesn't matter how many times you repeat that last bit, it still
    doesn't answer my question.

    You changed the wording of your claim to include the word ONLY, but it
    was unclear what the intent was.

    Then you simply did not pay close enough attention
    to the attempted rebuttal by Python.

    So you're not going to give me a simple (possibly qualified) answer to
    my yes/no question?

    I understand that you were trying to exclude Python's counterexample.
    What I don't understand is exactly how your ONLY achieves just this or
    exactly what ELSE it excludes. That's the big problem with ad hoc
    exclusions -- you often end up excluding things that you shouldn't have
    or things that you really didn't intend to.

    In another post you claimed that you hoped you would soon be ready for rigorous peer review. What you're undergoing in comp.theory is not peer review; it is simply discussion. If you were to ever submit to peer
    review you'd be expected to provide straight answers to questions, even
    if you don't like those questions or don't understand why they are being asked. The sorts of snide retorts you've been providing on this
    newsgroup would pretty much guarantee that your hypothetical paper would simply end up in the dustbin.

    Andr|-

    -aWhen you say HHH ONLY simulates DD.. you're presumably excluding some
    other case such as the case where HHH does something in addition to
    simulating DD, or simulates something in addition to DD. I'd
    interpreted it to mean that 'HHH ONLY simulates DD and does not abort
    it'. I'd asked if my interpretation was on the right track. That's a
    simply yes/no question. I've already ready your above passage many
    times and it does not provide answers to this question.

    So can you kindly simply answer with a yes or a no. If you want to
    include additional explanation that's fine, but please include a yes
    or a no.

    Andr|-



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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 19:59:46 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or
    simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive operations
    that compare strings (The standard libraries do; the language does not).
    So exactly which operations is it supposed to use? And if you claim that strcmp() is restricted to rely on strcmp() then you're caught in an
    infinitely recursive trap.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no restrictions
    on which sorts of operations a halt decider can make use of, provided it ultimately returns the correct answer.

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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 20:01:26 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:38 PM, Python wrote:
    Peter,

    -a-a-a "Then you simply did not pay close enough
    -a-a-a-a attention to the attempted rebuttal by Python."

    NO, PETER.

    ANDR|e IS PAYING ATTENTION.

    YOU ARE NOT.

    Andr|- has understood perfectly well WHY you added "ONLY".


    Then he was dishonest for asking why.

    I never asked 'why?'. I asked you to explain exactly what you intended
    by your use of the word ONLY, i.e. exactly which cases it was designed
    to exclude.

    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 comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 21:41:01 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 8:55 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:35, olcott wrote:
    On 11/12/2026 6:30 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 11:52, olcott wrote:
    On 11/12/2026 12:11 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 10:11, polcott wrote:
    On 11/12/2026 7:34 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 21:52, olcott wrote:
    On 11/11/2026 10:29 PM, Andr|- G. Isaak wrote:
    On 2026-11-11 10:23, olcott wrote:
    On 11/11/2026 10:59 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 09:29, olcott wrote:
    On 11/11/2026 9:30 AM, Andr|- G. Isaak wrote:
    On 2026-11-11 07:23, Python wrote:

    Your previous proposition said:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that simulates C function DD"

    Your new proposition says:

    -a-a-a "any implementation of C function HHH
    -a-a-a-a that ONLY simulates C function DD"

    YOU HAVE ADDED "ONLY".

    What exactly does "ONLY simulates" mean?

    I read this as meaning HHH only simulates DD as opposed to >>>>>>>>>>>>> testing for non-halting patterns and subsequently aborting DD. >>>>>>>>>>>>>
    If HHH /were/ a pure simulator (as opposed to a 'simulating >>>>>>>>>>>>> halt decider') then yes, HHH(DD) would be stuck in a >>>>>>>>>>>>> pattern of infinite recursion, but then it also wouldn't be >>>>>>>>>>>>> the HHH which he claims to be a potential halt decider, so >>>>>>>>>>>>> the argument falls apart.

    Andr|-


    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the >>>>>>>>>>>> operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement >>>>>>>>>>>> in any N finite number of steps.

    We can either map these words to

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

    Or map them to

    Computation defined
    A simplified Paraphrase of Emil Post definition of computation >>>>>>>>>>>> All Turing equivalent computations can be reduced to applying >>>>>>>>>>>> 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 string inputs is outside of the >>>>>>>>>>>> domain of ChurchrCoTuring computable functions.

    He'd asked for you to clarify the significance of the word >>>>>>>>>>> ONLY in your new formulation. I'd offered my interpretation, >>>>>>>>>>> but you neither confirm nor deny it. How does repeating three >>>>>>>>>>> things verbatim from your previous posts offer any sort of >>>>>>>>>>> clarification?

    Communication is not your strong point. Maybe try working on >>>>>>>>>>> that by actually providing the requested clarification. What >>>>>>>>>>> does the word ONLY achieve in your new formulation?

    Andr|-


    Because I spent 22 years of primary research from
    first principles I had to toss out everything that
    anyone thought that they knew about computation
    and start from scratch.

    This initially required me to correct the definitions
    of standard terms-of-the-art with my own adaptations.
    This caused most people to simply believe that I was
    not getting the meaning of those terms correctly.

    Now my reconstruction of the foundations of computation
    is complete I can prove my point in terms of a simplification >>>>>>>>>> of Post Canonical Systems string rewriting system (SRS),
    historically called a semi-Thue systems.

    Any computation that cannot be reduced to applying
    finite string transformations to finite string inputs
    is out of the scope of Turing Equivalent computation
    in the same way that filling your tires with air is
    outside of the scope of your toaster.

    None of the above addresses anything in my post. You have a >>>>>>>>> habit of doing this -- people ask questions or for
    clarifications and you simply repost stuff we've all already >>>>>>>>> read which doesn't actually answer anything. If what you posted >>>>>>>>> wasn't clear the first time, repeating it isn't going to
    provide any clarification.

    You'd been asked to clarify what you thought the inclusion of >>>>>>>>> the word 'ONLY' in your new wording accomplishes. I'd given my >>>>>>>>> best guess as to what you meant by this [still present in the >>>>>>>>> above quoted text], but your reply above leaves me none the >>>>>>>>> wiser about whether I was on the right track.

    Andr|-


    It avoids the possible issue that Python raised.
    Wasn't that as obvious as a pie in the face?

    Now you're just being an ass. If it were obvious I wouldn't be
    asking for clarification.

    Above I wrote that I thought by ONLY simulates DD you meant
    simulates as opposed to simulates with the possibility of
    aborting DD.


    While being simulated

    That doesn't clarify anything. It's not even a complete sentence.
    It certainly makes no mention of what you mean by ONLY.

    I'm asking for a simple confirmation or denial that this is what >>>>>>> you meant.

    Is the above really too much to ask?

    There does not exist any implementation of C function
    HHH that ONLY simulates C function DD according to the
    operational semantics of C such that the simulated C
    function DD reaches its own simulated return statement
    in any N finite number of steps.


    -a-aThere does not exist any implementation of C function
    -a-aHHH that ONLY simulates C function DD according to the
    -a-aoperational semantics of C such that the simulated C
    -a-afunction DD reaches its own simulated return statement
    -a-ain any N finite number of steps
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.
    while DD is being simulated by HHH.


    It doesn't matter how many times you repeat that last bit, it still
    doesn't answer my question.

    You changed the wording of your claim to include the word ONLY, but
    it was unclear what the intent was.

    Then you simply did not pay close enough attention
    to the attempted rebuttal by Python.

    So you're not going to give me a simple (possibly qualified) answer to
    my yes/no question?

    I understand that you were trying to exclude Python's counterexample.
    What I don't understand is exactly how your ONLY achieves just this or

    Then you did not pay attention to his counter-example.
    His example was no good because HHH must allocate
    a process context each time its simulates a new input.
    I will not spend time on anything that is not central
    to the point that I am making.

    I don't want to die without making my point
    because I tolerated people wasting my time
    like the 15 years that I wasted with
    Ben Bacarisse change-the-subject rebuttal.

    Probably the best version of this point is that
    HHH plays the same role as Prolog's
    unify_with_occurs_check() rejecting bad inputs.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    The final formal resolution of the Liar Paradox
    Copyright 2021 PL Olcott


    exactly what ELSE it excludes. That's the big problem with ad hoc
    exclusions -- you often end up excluding things that you shouldn't have
    or things that you really didn't intend to.

    In another post you claimed that you hoped you would soon be ready for rigorous peer review. What you're undergoing in comp.theory is not peer review; it is simply discussion. If you were to ever submit to peer
    review you'd be expected to provide straight answers to questions, even
    if you don't like those questions or don't understand why they are being asked. The sorts of snide retorts you've been providing on this
    newsgroup would pretty much guarantee that your hypothetical paper would simply end up in the dustbin.

    Andr|-

    -aWhen you say HHH ONLY simulates DD.. you're presumably excluding
    some other case such as the case where HHH does something in addition
    to simulating DD, or simulates something in addition to DD. I'd
    interpreted it to mean that 'HHH ONLY simulates DD and does not abort
    it'. I'd asked if my interpretation was on the right track. That's a
    simply yes/no question. I've already ready your above passage many
    times and it does not provide answers to this question.

    So can you kindly simply answer with a yes or a no. If you want to
    include additional explanation that's fine, but please include a yes
    or a no.

    Andr|-




    --
    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,comp.ai.philosophy on Thu Nov 12 21:45:42 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or
    simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive operations
    that compare strings (The standard libraries do; the language does not).
    So exactly which operations is it supposed to use? And if you claim that strcmp() is restricted to rely on strcmp() then you're caught in an infinitely recursive trap.


    It must somehow compare strings no version of
    playing tic-tac-toe will fulfill the requirements.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no restrictions
    on which sorts of operations a halt decider can make use of, provided it ultimately returns the correct answer.


    There actually are restrictions the same as there
    are restrictions for strcmp() no version of
    playing tic-tac-toe will fulfill the requirements.

    Only when we understand that the finite string
    transformations of all deciders must be relevant
    to the decision criteria do we see these things
    at this next deeper layer.

    Andr|-

    --
    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 21:19:40 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-12 20:45, olcott wrote:
    On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or
    simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive operations
    that compare strings (The standard libraries do; the language does
    not). So exactly which operations is it supposed to use? And if you
    claim that strcmp() is restricted to rely on strcmp() then you're
    caught in an infinitely recursive trap.


    It must somehow compare strings no version of
    playing tic-tac-toe will fulfill the requirements.

    You're entirely missing the point. C doesn't have any dedicated string-comparison operators. Nor does it have any tic-tac-toe specific operators. We define functions in terms of their ultimate results; not
    in terms of the intermediate operations they utilize. A tic-tac-toe
    program might well use string-comparison operations internally. Strcmp()
    might potentially use any operations it feels like internally (including
    ones used by tic-tac-toe) provided it's ultimate output is consistent
    with the function it is defined to perform.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no
    restrictions on which sorts of operations a halt decider can make use
    of, provided it ultimately returns the correct answer.


    There actually are restrictions the same as there
    are restrictions for strcmp() no version of
    playing tic-tac-toe will fulfill the requirements.

    No one claimed otherwise. A halt decider must answer the question 'does
    this input halt'. What operations it actually uses to accomplishes this
    are entirely irrelevant. You gave the example of AProVE. This program
    does not make use of operations which 'see' behaviour (whatever you
    might mean by that), nor does it emulate code, nor does it produce a
    trace up to the point where it can determine where something halts. It
    is judged not by these criteria but rather by whether it actually
    answers the questions which it claims to.

    Only when we understand that the finite string
    transformations of all deciders must be relevant
    to the decision criteria do we see these things
    at this next deeper layer.

    You spend a lot of time talking about finite string transformations, but
    I don't recall you ever specifically mentioning a specific finite string transformation. This is just a buzz word you've picked up. If you really
    think you can solve halting via finite string transformations then
    presumably you can identify all the transformations involved (using, for example, GREP syntax).

    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 comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 22:25:35 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 20:45, olcott wrote:
    On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or
    simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive
    operations that compare strings (The standard libraries do; the
    language does not). So exactly which operations is it supposed to
    use? And if you claim that strcmp() is restricted to rely on strcmp()
    then you're caught in an infinitely recursive trap.


    It must somehow compare strings no version of
    playing tic-tac-toe will fulfill the requirements.

    You're entirely missing the point. C doesn't have any dedicated string- comparison operators. Nor does it have any tic-tac-toe specific
    operators. We define functions in terms of their ultimate results; not
    in terms of the intermediate operations they utilize. A tic-tac-toe
    program might well use string-comparison operations internally. Strcmp() might potentially use any operations it feels like internally (including ones used by tic-tac-toe) provided it's ultimate output is consistent
    with the function it is defined to perform.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no
    restrictions on which sorts of operations a halt decider can make use
    of, provided it ultimately returns the correct answer.


    There actually are restrictions the same as there
    are restrictions for strcmp() no version of
    playing tic-tac-toe will fulfill the requirements.

    No one claimed otherwise. A halt decider must answer the question 'does
    this input halt'. What operations it actually uses to accomplishes this
    are entirely irrelevant. You gave the example of AProVE. This program
    does not make use of operations which 'see' behaviour (whatever you
    might mean by that), nor does it emulate code, nor does it produce a
    trace up to the point where it can determine where something halts. It
    is judged not by these criteria but rather by whether it actually
    answers the questions which it claims to.

    Only when we understand that the finite string
    transformations of all deciders must be relevant
    to the decision criteria do we see these things
    at this next deeper layer.

    You spend a lot of time talking about finite string transformations, but
    I don't recall you ever specifically mentioning a specific finite string transformation. This is just a buzz word you've picked up. If you really think you can solve halting via finite string transformations then presumably you can identify all the transformations involved (using, for example, GREP syntax).

    Andr|-


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    I specify the inherent requirement that deciders
    must apply finite string transformations that are
    relevant to the decision criteria. This provides
    a deeper understanding of the nature of deciders.

    There are more steps that depend on this one.
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 20:41:13 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 6:51 PM, olcott wrote:
    On 11/12/2026 8:40 PM, dart200 wrote:
    On 11/12/26 5:03 PM, dart200 wrote:
    On 11/12/26 4:51 PM, olcott wrote:
    On 11/12/2026 6:49 PM, dart200 wrote:
    On 11/12/26 1:53 PM, dart200 wrote:
    On 11/12/26 12:49 PM, olcott wrote:
    On 11/12/2026 2:26 PM, dart200 wrote:
    On 11/12/26 11:43 AM, olcott wrote:
    On 11/12/2026 1:07 PM, dart200 wrote:
    On 11/12/26 9:40 AM, olcott wrote:
    On 11/12/2026 1:16 AM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue >>>>>>>>>>>>>>>>>>> that pays complete attention and makes no >>>>>>>>>>>>>>>>>>> attempt to change the subject can confirm >>>>>>>>>>>>>>>>>>> that I am correct very quickly.

    Peter, have you considered the possibility that you >>>>>>>>>>>>>>>>>> are NOT correct?

    If I was not correct then at least one person >>>>>>>>>>>>>>>>> could point to an actual error in the last 22 years. >>>>>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>>>>> words to not conform to their false assumptions. >>>>>>>>>>>>>>>>>
    I can very much better show that these assumptions >>>>>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this >>>>>>>>>>>>>>>> without being wrong about something in regards to it, at >>>>>>>>>>>>>>>> least once???


    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>>>>> the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>>>>
    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according >>>>>>>>>>>>>>> to the operational semantics of the C programming >>>>>>>>>>>>>>> language specifies recursive simulation does seems >>>>>>>>>>>>>>> to indicate that most people here are dishonest. >>>>>>>>>>>>>>>

    the recursive simulation is purely a hypothetical based on >>>>>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>>>>> the recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>>>>> based on the invariant that HHH not cut DD simulation's >>>>>>>>>>>> short after the initial recursion is demonstrated.

    Yes that is correct.

    HHH only actually demonstrates one step of recursion, not >>>>>>>>>>>> infinite. the infinite recursion only occurs if HHH doesn't >>>>>>>>>>>> break the invariant of letting the simulation run, but HHH >>>>>>>>>>>> does break that invariant, so invalidating the induction >>>>>>>>>>>> requires to prove infinite recursion

    sipser said that same thing polcott


    Well that is good. You paid enough attention to
    not contradict yourself.

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

    Are you going to keep pretending that the Professor
    Sipser approved criteria has not been met?

    no u don't meet sipser's criteria, he explicitly specifies the >>>>>>>>>> decision is _not_ valid if DD is then aborted EfOa

    That is not even what those English words mean.
    I wrote those words and he approved them.


    ok so what does "unless aborted then" mean polcott?


    All non-halting behavior such as an infinite
    loop will continue to run unless aborted.


    and what does HHH ultimately do to the simulation of DD?


    polcott u didn't answer this...


    Makes bologna sandwiches?


    ur claiming that HHH makes bologna sandwiches with the simulation of DD? >>>
    are you just a fking troll bro?


    seriously bro after over 2 decades ur reduced to this level of
    trolling???

    everyone knows DD halts

    everyone knows HHH violates the invariant that sipser directly pointed
    out


    You can't even pay attention to the meaning of words.

    ur not fooling anyone but urself dud



    | ...H correctly determines that its simulated D would
    | never stop running *unless aborted then*

    u really can't admit what "unless aborted them" means, eh?
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 21:42:21 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-12 21:25, olcott wrote:
    On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 20:45, olcott wrote:
    On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or
    simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive
    operations that compare strings (The standard libraries do; the
    language does not). So exactly which operations is it supposed to
    use? And if you claim that strcmp() is restricted to rely on
    strcmp() then you're caught in an infinitely recursive trap.


    It must somehow compare strings no version of
    playing tic-tac-toe will fulfill the requirements.

    You're entirely missing the point. C doesn't have any dedicated
    string- comparison operators. Nor does it have any tic-tac-toe
    specific operators. We define functions in terms of their ultimate
    results; not in terms of the intermediate operations they utilize. A
    tic-tac-toe program might well use string-comparison operations
    internally. Strcmp() might potentially use any operations it feels
    like internally (including ones used by tic-tac-toe) provided it's
    ultimate output is consistent with the function it is defined to perform.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no
    restrictions on which sorts of operations a halt decider can make
    use of, provided it ultimately returns the correct answer.


    There actually are restrictions the same as there
    are restrictions for strcmp() no version of
    playing tic-tac-toe will fulfill the requirements.

    No one claimed otherwise. A halt decider must answer the question
    'does this input halt'. What operations it actually uses to
    accomplishes this are entirely irrelevant. You gave the example of
    AProVE. This program does not make use of operations which 'see'
    behaviour (whatever you might mean by that), nor does it emulate code,
    nor does it produce a trace up to the point where it can determine
    where something halts. It is judged not by these criteria but rather
    by whether it actually answers the questions which it claims to.

    Only when we understand that the finite string
    transformations of all deciders must be relevant
    to the decision criteria do we see these things
    at this next deeper layer.

    You spend a lot of time talking about finite string transformations,
    but I don't recall you ever specifically mentioning a specific finite
    string transformation. This is just a buzz word you've picked up. If
    you really think you can solve halting via finite string
    transformations then presumably you can identify all the
    transformations involved (using, for example, GREP syntax).

    Andr|-


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    I specify the inherent requirement that deciders
    must apply finite string transformations that are
    relevant to the decision criteria. This provides
    a deeper understanding of the nature of deciders.

    You've given a few non-controversial definitions which don't mention any actual finite string transformation rules.

    So give me an example of such as finite string transformation rule
    relevant to deciding a particular language (For example, the language
    which describes all halting machines). Specify an *actual* rule. Don't
    just talk in terms of vague generalities. Again, GREP syntax would be appropriate for your example.

    If you can't specify an actual rule it becomes apparent you're just
    throwing random terminology around without any actual understanding.

    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 comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 22:45:44 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 10:42 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 21:25, olcott wrote:
    On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 20:45, olcott wrote:
    On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or >>>>>>> simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive
    operations that compare strings (The standard libraries do; the
    language does not). So exactly which operations is it supposed to
    use? And if you claim that strcmp() is restricted to rely on
    strcmp() then you're caught in an infinitely recursive trap.


    It must somehow compare strings no version of
    playing tic-tac-toe will fulfill the requirements.

    You're entirely missing the point. C doesn't have any dedicated
    string- comparison operators. Nor does it have any tic-tac-toe
    specific operators. We define functions in terms of their ultimate
    results; not in terms of the intermediate operations they utilize. A
    tic-tac-toe program might well use string-comparison operations
    internally. Strcmp() might potentially use any operations it feels
    like internally (including ones used by tic-tac-toe) provided it's
    ultimate output is consistent with the function it is defined to
    perform.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no
    restrictions on which sorts of operations a halt decider can make
    use of, provided it ultimately returns the correct answer.


    There actually are restrictions the same as there
    are restrictions for strcmp() no version of
    playing tic-tac-toe will fulfill the requirements.

    No one claimed otherwise. A halt decider must answer the question
    'does this input halt'. What operations it actually uses to
    accomplishes this are entirely irrelevant. You gave the example of
    AProVE. This program does not make use of operations which 'see'
    behaviour (whatever you might mean by that), nor does it emulate
    code, nor does it produce a trace up to the point where it can
    determine where something halts. It is judged not by these criteria
    but rather by whether it actually answers the questions which it
    claims to.

    Only when we understand that the finite string
    transformations of all deciders must be relevant
    to the decision criteria do we see these things
    at this next deeper layer.

    You spend a lot of time talking about finite string transformations,
    but I don't recall you ever specifically mentioning a specific finite
    string transformation. This is just a buzz word you've picked up. If
    you really think you can solve halting via finite string
    transformations then presumably you can identify all the
    transformations involved (using, for example, GREP syntax).

    Andr|-


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    I specify the inherent requirement that deciders
    must apply finite string transformations that are
    relevant to the decision criteria. This provides
    a deeper understanding of the nature of deciders.

    You've given a few non-controversial definitions which don't mention any actual finite string transformation rules.

    So give me an example of such as finite string transformation rule
    relevant to deciding a particular language (For example, the language
    which describes all halting machines). Specify an *actual* rule. Don't
    just talk in terms of vague generalities. Again, GREP syntax would be appropriate for your example.


    I have done this for four years now.
    What is the category of finite string transformation
    that HHH could apply to the C source code of DD?

    If you can't specify an actual rule it becomes apparent you're just
    throwing random terminology around without any actual understanding.

    Andr|-

    --
    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 21:55:03 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-12 21:45, olcott wrote:
    On 11/12/2026 10:42 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 21:25, olcott wrote:
    On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 20:45, olcott wrote:
    On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or >>>>>>>> simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive
    operations that compare strings (The standard libraries do; the
    language does not). So exactly which operations is it supposed to >>>>>> use? And if you claim that strcmp() is restricted to rely on
    strcmp() then you're caught in an infinitely recursive trap.


    It must somehow compare strings no version of
    playing tic-tac-toe will fulfill the requirements.

    You're entirely missing the point. C doesn't have any dedicated
    string- comparison operators. Nor does it have any tic-tac-toe
    specific operators. We define functions in terms of their ultimate
    results; not in terms of the intermediate operations they utilize. A
    tic-tac-toe program might well use string-comparison operations
    internally. Strcmp() might potentially use any operations it feels
    like internally (including ones used by tic-tac-toe) provided it's
    ultimate output is consistent with the function it is defined to
    perform.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no
    restrictions on which sorts of operations a halt decider can make >>>>>> use of, provided it ultimately returns the correct answer.


    There actually are restrictions the same as there
    are restrictions for strcmp() no version of
    playing tic-tac-toe will fulfill the requirements.

    No one claimed otherwise. A halt decider must answer the question
    'does this input halt'. What operations it actually uses to
    accomplishes this are entirely irrelevant. You gave the example of
    AProVE. This program does not make use of operations which 'see'
    behaviour (whatever you might mean by that), nor does it emulate
    code, nor does it produce a trace up to the point where it can
    determine where something halts. It is judged not by these criteria
    but rather by whether it actually answers the questions which it
    claims to.

    Only when we understand that the finite string
    transformations of all deciders must be relevant
    to the decision criteria do we see these things
    at this next deeper layer.

    You spend a lot of time talking about finite string transformations,
    but I don't recall you ever specifically mentioning a specific
    finite string transformation. This is just a buzz word you've picked
    up. If you really think you can solve halting via finite string
    transformations then presumably you can identify all the
    transformations involved (using, for example, GREP syntax).

    Andr|-


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    I specify the inherent requirement that deciders
    must apply finite string transformations that are
    relevant to the decision criteria. This provides
    a deeper understanding of the nature of deciders.

    You've given a few non-controversial definitions which don't mention
    any actual finite string transformation rules.

    So give me an example of such as finite string transformation rule
    relevant to deciding a particular language (For example, the language
    which describes all halting machines). Specify an *actual* rule. Don't
    just talk in terms of vague generalities. Again, GREP syntax would be
    appropriate for your example.


    I have done this for four years now.
    What is the category of finite string transformation
    that HHH could apply to the C source code of DD?


    That's a question. And a rather poorly-posed one at that. I asked for an *example* of a finite string transformation rule.

    What exactly is the 'category' of a finite string transformation? That question doesn't even make sense.

    An actual rule would take the form of

    String A -> String B

    Explain exactly what A and B are here. GREP/Regex would be an
    appropriate syntax for specifying this. Vague handwaving wouldn't be.

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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Thu Nov 12 20:55:46 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 12:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT
    correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }

    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
    of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and classifying them the same

    how do u respond to this inconsistency polcott?

    polcott u still haven't responded to the fact HHH classifies both
    halting DD and non-halting DD2 into the same set of machines with the
    same semantic halting behavior...

    this is truly a 1 = 0 type of fault



    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial
    recursion is demonstrated. HHH only actually demonstrates one step of
    recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH
    does break that invariant, so invalidating the induction requires to
    prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott






    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 23:04:20 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 10:55 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 21:45, olcott wrote:
    On 11/12/2026 10:42 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 21:25, olcott wrote:
    On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 20:45, olcott wrote:
    On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing >>>>>>>>> or simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive
    operations that compare strings (The standard libraries do; the >>>>>>> language does not). So exactly which operations is it supposed to >>>>>>> use? And if you claim that strcmp() is restricted to rely on
    strcmp() then you're caught in an infinitely recursive trap.


    It must somehow compare strings no version of
    playing tic-tac-toe will fulfill the requirements.

    You're entirely missing the point. C doesn't have any dedicated
    string- comparison operators. Nor does it have any tic-tac-toe
    specific operators. We define functions in terms of their ultimate
    results; not in terms of the intermediate operations they utilize.
    A tic-tac-toe program might well use string-comparison operations
    internally. Strcmp() might potentially use any operations it feels
    like internally (including ones used by tic-tac-toe) provided it's
    ultimate output is consistent with the function it is defined to
    perform.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no
    restrictions on which sorts of operations a halt decider can make >>>>>>> use of, provided it ultimately returns the correct answer.


    There actually are restrictions the same as there
    are restrictions for strcmp() no version of
    playing tic-tac-toe will fulfill the requirements.

    No one claimed otherwise. A halt decider must answer the question
    'does this input halt'. What operations it actually uses to
    accomplishes this are entirely irrelevant. You gave the example of
    AProVE. This program does not make use of operations which 'see'
    behaviour (whatever you might mean by that), nor does it emulate
    code, nor does it produce a trace up to the point where it can
    determine where something halts. It is judged not by these criteria >>>>> but rather by whether it actually answers the questions which it
    claims to.

    Only when we understand that the finite string
    transformations of all deciders must be relevant
    to the decision criteria do we see these things
    at this next deeper layer.

    You spend a lot of time talking about finite string
    transformations, but I don't recall you ever specifically
    mentioning a specific finite string transformation. This is just a
    buzz word you've picked up. If you really think you can solve
    halting via finite string transformations then presumably you can
    identify all the transformations involved (using, for example, GREP >>>>> syntax).

    Andr|-


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    I specify the inherent requirement that deciders
    must apply finite string transformations that are
    relevant to the decision criteria. This provides
    a deeper understanding of the nature of deciders.

    You've given a few non-controversial definitions which don't mention
    any actual finite string transformation rules.

    So give me an example of such as finite string transformation rule
    relevant to deciding a particular language (For example, the language
    which describes all halting machines). Specify an *actual* rule.
    Don't just talk in terms of vague generalities. Again, GREP syntax
    would be appropriate for your example.


    I have done this for four years now.
    What is the category of finite string transformation
    that HHH could apply to the C source code of DD?


    That's a question. And a rather poorly-posed one at that. I asked for an *example* of a finite string transformation rule.

    What exactly is the 'category' of a finite string transformation? That question doesn't even make sense.

    An actual rule would take the form of

    String A -> String B

    Explain exactly what A and B are here. GREP/Regex would be an
    appropriate syntax for specifying this. Vague handwaving wouldn't be.

    Andr|-


    What category of a finite string transformation
    rule does strcmp() to derive 0 or non-zero?
    --
    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Thu Nov 12 22:21:29 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-12 22:04, olcott wrote:
    On 11/12/2026 10:55 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 21:45, olcott wrote:
    On 11/12/2026 10:42 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 21:25, olcott wrote:
    On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 20:45, olcott wrote:
    On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing >>>>>>>>>> or simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive
    operations that compare strings (The standard libraries do; the >>>>>>>> language does not). So exactly which operations is it supposed >>>>>>>> to use? And if you claim that strcmp() is restricted to rely on >>>>>>>> strcmp() then you're caught in an infinitely recursive trap.


    It must somehow compare strings no version of
    playing tic-tac-toe will fulfill the requirements.

    You're entirely missing the point. C doesn't have any dedicated
    string- comparison operators. Nor does it have any tic-tac-toe
    specific operators. We define functions in terms of their ultimate >>>>>> results; not in terms of the intermediate operations they utilize. >>>>>> A tic-tac-toe program might well use string-comparison operations >>>>>> internally. Strcmp() might potentially use any operations it feels >>>>>> like internally (including ones used by tic-tac-toe) provided it's >>>>>> ultimate output is consistent with the function it is defined to
    perform.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no
    restrictions on which sorts of operations a halt decider can
    make use of, provided it ultimately returns the correct answer. >>>>>>>>

    There actually are restrictions the same as there
    are restrictions for strcmp() no version of
    playing tic-tac-toe will fulfill the requirements.

    No one claimed otherwise. A halt decider must answer the question >>>>>> 'does this input halt'. What operations it actually uses to
    accomplishes this are entirely irrelevant. You gave the example of >>>>>> AProVE. This program does not make use of operations which 'see'
    behaviour (whatever you might mean by that), nor does it emulate
    code, nor does it produce a trace up to the point where it can
    determine where something halts. It is judged not by these
    criteria but rather by whether it actually answers the questions
    which it claims to.

    Only when we understand that the finite string
    transformations of all deciders must be relevant
    to the decision criteria do we see these things
    at this next deeper layer.

    You spend a lot of time talking about finite string
    transformations, but I don't recall you ever specifically
    mentioning a specific finite string transformation. This is just a >>>>>> buzz word you've picked up. If you really think you can solve
    halting via finite string transformations then presumably you can >>>>>> identify all the transformations involved (using, for example,
    GREP syntax).

    Andr|-


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    I specify the inherent requirement that deciders
    must apply finite string transformations that are
    relevant to the decision criteria. This provides
    a deeper understanding of the nature of deciders.

    You've given a few non-controversial definitions which don't mention
    any actual finite string transformation rules.

    So give me an example of such as finite string transformation rule
    relevant to deciding a particular language (For example, the
    language which describes all halting machines). Specify an *actual*
    rule. Don't just talk in terms of vague generalities. Again, GREP
    syntax would be appropriate for your example.


    I have done this for four years now.
    What is the category of finite string transformation
    that HHH could apply to the C source code of DD?


    That's a question. And a rather poorly-posed one at that. I asked for
    an *example* of a finite string transformation rule.

    What exactly is the 'category' of a finite string transformation? That
    question doesn't even make sense.

    An actual rule would take the form of

    String A -> String B

    Explain exactly what A and B are here. GREP/Regex would be an
    appropriate syntax for specifying this. Vague handwaving wouldn't be.

    Andr|-


    What category of a finite string transformation
    rule does strcmp() to derive 0 or non-zero?

    That's not even a coherent question.

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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 10:58:06 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Every termination analyzer must always somehow
    determine the sequence of steps required to
    determine whether an input finite string specifies
    behavior that reaches a final state or not."

    YOU ARE CONFUSING TWO ENTIRELY DIFFERENT SEQUENCES OF STEPS.

    1. The steps performed by the ANALYZER.

    2. The steps performed by the PROGRAM BEING ANALYZED.

    Of course, a computable analyzer performs computational steps.

    THAT DOES NOT MEAN IT MUST RECONSTRUCT THE EXECUTION STEPS OF ITS INPUT PROGRAM.

    Consider again:

    int f(unsigned n)
    {
    while (n > 0)
    --n;
    return 0;
    }

    A termination analyzer can establish that f terminates for every unsigned
    n by finding a ranking function: n decreases strictly on each iteration
    and is bounded below by zero.

    The analyzer manipulates mathematical properties of the program.

    IT DOES NOT NEED TO SIMULATE ITS EXECUTION.

    "For Turing computable functions this must always
    be consistent with D simulated by H."

    If "consistent" means that H's answer must agree with D's actual
    termination behavior, OF COURSE.

    That is called CORRECTNESS.

    But if you mean that H must obtain its answer by simulating D, NO.

    THAT IS NOT A REQUIREMENT OF COMPUTABILITY THEORY.

    You have simply replaced the definition of a halting decider with your own restricted implementation model.

    And then you complain that the standard theorem does not respect your restriction.

    OF COURSE IT DOESN'T.

    THE RESTRICTION IS YOUR INVENTION.

    One question, Peter:

    DO YOU UNDERSTAND THAT AN ANALYZER'S COMPUTATION STEPS ARE NOT THE SAME
    THING AS THE EXECUTION STEPS OF THE PROGRAM IT ANALYZES?

    YES OR NO?

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From polcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 09:27:55 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 4:58 AM, Python wrote:
    Peter,

    "Every termination analyzer must always somehow
    determine the sequence of steps required to
    determine whether an input finite string specifies
    behavior that reaches a final state or not."

    YOU ARE CONFUSING TWO ENTIRELY DIFFERENT SEQUENCES OF STEPS.

    1. The steps performed by the ANALYZER.

    2. The steps performed by the PROGRAM BEING ANALYZED.

    That is not my mistake. Turing equivalent computation
    is utterly restricted to the former.

    In those cases where D does not call H(D)
    its own decider (1) is a proxy for (2).
    In other cases H act like unify_with_occurs_check()
    and rejects the pathological self-reference.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    Of course, a computable analyzer performs computational steps.

    THAT DOES NOT MEAN IT MUST RECONSTRUCT THE EXECUTION STEPS OF ITS INPUT PROGRAM.

    Consider again:

    int f(unsigned n)
    {
    while (n > 0)
    --n;
    return 0;
    }

    A termination analyzer can establish that f terminates for every
    unsigned n by finding a ranking function: n decreases strictly on each iteration and is bounded below by zero.

    And these results must be (as I have said) equivalent
    to the behavior of f simulated by H.

    That is a very good example of how a pattern matching
    short-cut to actual simulation can be created.

    The analyzer manipulates mathematical properties of the program.

    IT DOES NOT NEED TO SIMULATE ITS EXECUTION.

    If it is not examining the sequence of steps at
    least at some level of abstraction then it cannot
    possibly determine whether or not this sequence of
    steps does reach a final state.

    "For Turing computable functions this must always
    be consistent with D simulated by H."

    If "consistent" means that H's answer must agree with D's actual
    termination behavior, OF COURSE.

    So are are smart and knowledgeable enough to
    understand me. Since the bottom line of correctness
    must be equivalent to D simulated by H the actual
    behavior of D simulated by H would be the most
    definitive measure of this.

    That is called CORRECTNESS.

    But if you mean that H must obtain its answer by simulating D, NO.

    THAT IS NOT A REQUIREMENT OF COMPUTABILITY THEORY.

    You have simply replaced the definition of a halting decider with your
    own restricted implementation model.

    D simulated by H provides the definitive measure of
    the behavior of the input to H that can be derived
    by applying finite string transformations to this
    input by H.

    And then you complain that the standard theorem does not respect your restriction.

    OF COURSE IT DOESN'T.

    THE RESTRICTION IS YOUR INVENTION.

    One question, Peter:

    DO YOU UNDERSTAND THAT AN ANALYZER'S COMPUTATION STEPS ARE NOT THE SAME THING AS THE EXECUTION STEPS OF THE PROGRAM IT ANALYZES?

    YES OR NO?
    H1(D) derives the exact same steps as int main() { D(); }
    H(D) does not derive these exact same steps because
    D calls H(D) in recursive simulation.

    This is probably best thought of as H acting as if it was unify_with_occurs_check() rejecting bad input.
    --
    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 polcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 09:34:13 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 11:21 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 22:04, olcott wrote:
    On 11/12/2026 10:55 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 21:45, olcott wrote:
    On 11/12/2026 10:42 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 21:25, olcott wrote:
    On 11/12/2026 10:19 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 20:45, olcott wrote:
    On 11/12/2026 8:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach >>>>>>>>>>> -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing >>>>>>>>>>> or simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive >>>>>>>>> operations that compare strings (The standard libraries do; the >>>>>>>>> language does not). So exactly which operations is it supposed >>>>>>>>> to use? And if you claim that strcmp() is restricted to rely on >>>>>>>>> strcmp() then you're caught in an infinitely recursive trap. >>>>>>>>>

    It must somehow compare strings no version of
    playing tic-tac-toe will fulfill the requirements.

    You're entirely missing the point. C doesn't have any dedicated >>>>>>> string- comparison operators. Nor does it have any tic-tac-toe
    specific operators. We define functions in terms of their
    ultimate results; not in terms of the intermediate operations
    they utilize. A tic-tac-toe program might well use string-
    comparison operations internally. Strcmp() might potentially use >>>>>>> any operations it feels like internally (including ones used by >>>>>>> tic-tac-toe) provided it's ultimate output is consistent with the >>>>>>> function it is defined to perform.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no >>>>>>>>> restrictions on which sorts of operations a halt decider can >>>>>>>>> make use of, provided it ultimately returns the correct answer. >>>>>>>>>

    There actually are restrictions the same as there
    are restrictions for strcmp() no version of
    playing tic-tac-toe will fulfill the requirements.

    No one claimed otherwise. A halt decider must answer the question >>>>>>> 'does this input halt'. What operations it actually uses to
    accomplishes this are entirely irrelevant. You gave the example >>>>>>> of AProVE. This program does not make use of operations which
    'see' behaviour (whatever you might mean by that), nor does it
    emulate code, nor does it produce a trace up to the point where >>>>>>> it can determine where something halts. It is judged not by these >>>>>>> criteria but rather by whether it actually answers the questions >>>>>>> which it claims to.

    Only when we understand that the finite string
    transformations of all deciders must be relevant
    to the decision criteria do we see these things
    at this next deeper layer.

    You spend a lot of time talking about finite string
    transformations, but I don't recall you ever specifically
    mentioning a specific finite string transformation. This is just >>>>>>> a buzz word you've picked up. If you really think you can solve >>>>>>> halting via finite string transformations then presumably you can >>>>>>> identify all the transformations involved (using, for example,
    GREP syntax).

    Andr|-


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    I specify the inherent requirement that deciders
    must apply finite string transformations that are
    relevant to the decision criteria. This provides
    a deeper understanding of the nature of deciders.

    You've given a few non-controversial definitions which don't
    mention any actual finite string transformation rules.

    So give me an example of such as finite string transformation rule
    relevant to deciding a particular language (For example, the
    language which describes all halting machines). Specify an *actual* >>>>> rule. Don't just talk in terms of vague generalities. Again, GREP
    syntax would be appropriate for your example.


    I have done this for four years now.
    What is the category of finite string transformation
    that HHH could apply to the C source code of DD?


    That's a question. And a rather poorly-posed one at that. I asked for
    an *example* of a finite string transformation rule.

    What exactly is the 'category' of a finite string transformation?
    That question doesn't even make sense.

    An actual rule would take the form of

    String A -> String B

    Explain exactly what A and B are here. GREP/Regex would be an
    appropriate syntax for specifying this. Vague handwaving wouldn't be.

    Andr|-


    What category of a finite string transformation
    rule does strcmp() to derive 0 or non-zero?

    That's not even a coherent question.

    Andr|-


    It is playing a game of tic-tac-toe or is
    it some underlying process that is applied
    to some relevant decision criteria?

    Likewise an even partial halt decider must
    somehow examine the behavior specified by its
    input finite string. Playing a game of
    tic-tac-toe will not meet the decision criteria
    of any halt decider.
    --
    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@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 15:40:31 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Turing equivalent computation is utterly
    restricted to the former."

    Of course a Turing-computable analyzer performs computational steps.

    BUT SO DOES THE PROGRAM BEING ANALYZED.

    You are confusing two distinct computations:

    1. The computation performed by the analyzer H.
    2. The computation performed by its input D.

    Both are perfectly legitimate Turing computations.

    There is NO requirement that their execution traces be identical.

    "In those cases where D does not call H(D)
    its own decider (1) is a proxy for (2)."

    An analyzer can reason about a program without simulating it, whether or
    not that program calls the analyzer.

    If H happens to simulate D, that is an implementation choice.

    NOT A REQUIREMENT OF COMPUTABILITY THEORY.

    "And these results must be [...] equivalent
    to the behavior of f simulated by H."

    YES!

    The RESULT must agree with the actual termination behavior of f.

    The COMPUTATION producing that result need not reproduce f's execution.

    And you have just acknowledged that a ranking-function argument provides a shortcut to simulation.

    GOOD.

    THEN SIMULATION IS NOT REQUIRED.

    "If it is not examining the sequence of steps
    at least at some level of abstraction then it
    cannot possibly determine whether or not this
    sequence of steps does reach a final state."

    You are now confusing ANALYZING a program's transition rules with RECONSTRUCTING its execution trace.

    A ranking function proves termination by establishing a decreasing, well-founded measure.

    An invariant can establish nontermination by proving that execution
    remains forever in a nonterminal region.

    Neither technique requires enumerating the execution trace.

    And both can be implemented by Turing-computable algorithms.

    "Since the bottom line of correctness must be
    equivalent to D simulated by H the actual
    behavior of D simulated by H would be the
    most definitive measure of this."

    NO.

    The definitive criterion is the behavior of D under its specified
    execution semantics.

    A simulator is merely one method of investigating that behavior.

    A simulator that aborts, changes the execution context, or fails to
    reproduce the relevant machine state cannot simply declare its
    observations definitive.

    "H1(D) derives the exact same steps as
    int main() { D(); }
    H(D) does not derive these exact same steps
    because D calls H(D) in recursive simulation."

    THEN YOU ARE DESCRIBING TWO DIFFERENT EXECUTION CONTEXTS.

    If H1 and H do not reproduce the same conditions, their execution traces
    need not coincide.

    That is a property of your implementations.

    NOT A LIMITATION OF TURING COMPUTATION.

    And the standard Halting Theorem does not assume that H works by
    recursively simulating D.

    It assumes that H is a TOTAL, CORRECT, COMPUTABLE halting decider.

    HOW H OBTAINS ITS ANSWER IS IRRELEVANT.

    "In other cases H act like
    unify_with_occurs_check() and rejects
    the pathological self-reference."

    AND HERE IS YOUR NEW CONFUSION.

    In Prolog, `unify_with_occurs_check/2` prevents certain cyclic term constructions.

    It does NOT establish that self-referential computations are impossible.

    It does NOT establish that recursive programs are invalid.

    And it certainly does NOT establish that diagonal computations lie outside Turing computation.

    You are confusing a restriction on term unification with a theorem about computability.

    A Turing machine can simulate recursive calls.

    It can simulate programs that refer to their own descriptions.

    It can simulate computations that never terminate.

    THERE IS NOTHING "PATHOLOGICAL" ABOUT THESE COMPUTATIONS.

    The limitation is that no Turing-computable algorithm can correctly DECIDE halting for every arbitrary program and input.

    And now you propose that H should reject D because it recognizes self-reference.

    REJECT IT AS WHAT, PETER?

    If rejection means "D does not halt", then you must PROVE that conclusion correct.

    If rejection means "D is invalid", then you have excluded a valid program
    from your alleged universal decider's domain.

    If rejection means "H cannot decide", then H is not a total halting
    decider.

    NONE OF THESE REFUTES THE HALTING THEOREM.

    In fact, your analogy with `unify_with_occurs_check()` exposes your fundamental mistake.

    You are treating an implementation-specific rejection rule as though it established a fundamental impossibility of computation.

    IT DOES NOT.

    And declaring the diagonal input "pathological" does not make the diagonal argument disappear.

    It merely means that your proposed H refuses to handle precisely the case
    a universal decider MUST handle.

    So here is ONE question:

    WHEN H "REJECTS" D, DOES IT RETURN "DOES NOT HALT", "INVALID INPUT", OR "UNABLE TO DECIDE"?

    WHICH ONE?

    And please do not confuse the inability of YOUR simulator to process an
    input with the inability of a Turing machine to compute its behavior.

    THEY ARE NOT THE SAME THING.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From polcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 09:55:18 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 9:40 AM, Python wrote:
    Peter,

    -a-a "Turing equivalent computation is utterly
    -a-a-a restricted to the former."

    Of course a Turing-computable analyzer performs computational steps.

    BUT SO DOES THE PROGRAM BEING ANALYZED.


    That is the big mistake. There never was any program
    being analyzed. It has always been a static finite
    of what is essentially source code within the language
    of computation.

    ALL Turing equivalent Computation must be able to be
    reduced to applying finite string transformations to
    finite string inputs to derive any and all outputs.

    You are confusing two distinct computations:

    1. The computation performed by the analyzer H.
    2. The computation performed by its input D.

    Both are perfectly legitimate Turing computations.

    There is NO requirement that their execution traces be identical.

    -a-a "In those cases where D does not call H(D)
    -a-a-a its own decider (1) is a proxy for (2)."

    An analyzer can reason about a program without simulating it, whether or
    not that program calls the analyzer.

    If H happens to simulate D, that is an implementation choice.

    NOT A REQUIREMENT OF COMPUTABILITY THEORY.

    -a-a "And these results must be [...] equivalent
    -a-a-a to the behavior of f simulated by H."

    YES!

    The RESULT must agree with the actual termination behavior of f.


    Wrong. The result must be consistent with D simulated by
    H because the result can only be derived by applying finite
    string transformations to actual finite string inputs.

    The ultimate measure of whether the input specifies a
    sequence of steps that can reach a finite state is D
    simulated by H.

    The COMPUTATION producing that result need not reproduce f's execution.

    And you have just acknowledged that a ranking-function argument provides
    a shortcut to simulation.

    GOOD.

    THEN SIMULATION IS NOT REQUIRED.

    -a-a "If it is not examining the sequence of steps
    -a-a-a at least at some level of abstraction then it
    -a-a-a cannot possibly determine whether or not this
    -a-a-a sequence of steps does reach a final state."

    You are now confusing ANALYZING a program's transition rules with RECONSTRUCTING its execution trace.

    A ranking function proves termination by establishing a decreasing, well-founded measure.

    An invariant can establish nontermination by proving that execution
    remains forever in a nonterminal region.

    Neither technique requires enumerating the execution trace.

    And both can be implemented by Turing-computable algorithms.

    -a-a "Since the bottom line of correctness must be
    -a-a-a equivalent to D simulated by H the actual
    -a-a-a behavior of D simulated by H would be the
    -a-a-a most definitive measure of this."

    NO.

    The definitive criterion is the behavior of D under its specified
    execution semantics.

    A simulator is merely one method of investigating that behavior.

    A simulator that aborts, changes the execution context, or fails to reproduce the relevant machine state cannot simply declare its
    observations definitive.

    -a-a "H1(D) derives the exact same steps as
    -a-a-a int main() { D(); }
    -a-a-a H(D) does not derive these exact same steps
    -a-a-a because D calls H(D) in recursive simulation."

    THEN YOU ARE DESCRIBING TWO DIFFERENT EXECUTION CONTEXTS.

    If H1 and H do not reproduce the same conditions, their execution traces need not coincide.

    That is a property of your implementations.

    NOT A LIMITATION OF TURING COMPUTATION.

    And the standard Halting Theorem does not assume that H works by
    recursively simulating D.

    It assumes that H is a TOTAL, CORRECT, COMPUTABLE halting decider.

    HOW H OBTAINS ITS ANSWER IS IRRELEVANT.

    -a-a "In other cases H act like
    -a-a-a unify_with_occurs_check() and rejects
    -a-a-a the pathological self-reference."

    AND HERE IS YOUR NEW CONFUSION.

    In Prolog, `unify_with_occurs_check/2` prevents certain cyclic term constructions.

    It does NOT establish that self-referential computations are impossible.

    It does NOT establish that recursive programs are invalid.

    And it certainly does NOT establish that diagonal computations lie
    outside Turing computation.

    You are confusing a restriction on term unification with a theorem about computability.

    A Turing machine can simulate recursive calls.

    It can simulate programs that refer to their own descriptions.

    It can simulate computations that never terminate.

    THERE IS NOTHING "PATHOLOGICAL" ABOUT THESE COMPUTATIONS.

    The limitation is that no Turing-computable algorithm can correctly
    DECIDE halting for every arbitrary program and input.

    And now you propose that H should reject D because it recognizes self- reference.

    REJECT IT AS WHAT, PETER?

    If rejection means "D does not halt", then you must PROVE that
    conclusion correct.

    If rejection means "D is invalid", then you have excluded a valid
    program from your alleged universal decider's domain.

    If rejection means "H cannot decide", then H is not a total halting
    decider.

    NONE OF THESE REFUTES THE HALTING THEOREM.

    In fact, your analogy with `unify_with_occurs_check()` exposes your fundamental mistake.

    You are treating an implementation-specific rejection rule as though it established a fundamental impossibility of computation.

    IT DOES NOT.

    And declaring the diagonal input "pathological" does not make the
    diagonal argument disappear.

    It merely means that your proposed H refuses to handle precisely the
    case a universal decider MUST handle.

    So here is ONE question:

    WHEN H "REJECTS" D, DOES IT RETURN "DOES NOT HALT", "INVALID INPUT", OR "UNABLE TO DECIDE"?

    WHICH ONE?

    And please do not confuse the inability of YOUR simulator to process an input with the inability of a Turing machine to compute its behavior.

    THEY ARE NOT THE SAME THING.
    --
    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@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 17:15:40 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "There never was any program being analyzed.
    It has always been a static finite [string]
    of what is essentially source code."

    FOR FUCK'S SAKE.

    A program's source code IS a finite string.

    And that string SPECIFIES a computation.

    THAT IS THE WHOLE POINT OF COMPUTABILITY THEORY.

    Nobody claims that H must physically execute its input.

    "ALL Turing equivalent Computation must be able
    to be reduced to applying finite string
    transformations to finite string inputs"

    YES!

    INCLUDING STATIC ANALYSIS.

    INCLUDING MATHEMATICAL PROOFS.

    INCLUDING THE DIAGONAL CONSTRUCTION.

    You have just restated a standard fact about computability and somehow convinced yourself it refutes computability theory.

    "The ultimate measure [...] is D simulated by H."

    NO.

    The ultimate criterion is whether D HALTS under its specified semantics.

    YOUR SIMULATOR IS NOT THE ARBITER OF MATHEMATICAL TRUTH.

    And you STILL haven't answered the question:

    When H rejects D, does that mean:

    - D DOES NOT HALT?
    - D IS INVALID?
    - H CANNOT DECIDE?

    PICK ONE.

    You have spent 22 years confusing a program's description, its execution,
    and your simulator's behavior.

    And you still cannot answer a three-choice question about your own
    algorithm.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 12:11:09 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 11:15 AM, Python wrote:
    Peter,

    -a-a "There never was any program being analyzed.
    -a-a-a It has always been a static finite [string]
    -a-a-a of what is essentially source code."

    FOR FUCK'S SAKE.

    A program's source code IS a finite string.


    Yes.

    And that string SPECIFIES a computation.


    Not exactly. H(D) must take into account that
    D calls H(D) in recursive simulation. H cannot
    ignore this when it is applying finite string
    transformation inference steps within the operational
    semantics of the C/x86 language.

    THAT IS THE WHOLE POINT OF COMPUTABILITY THEORY.

    Nobody claims that H must physically execute its input.

    -a-a "ALL Turing equivalent Computation must be able
    -a-a-a to be reduced to applying finite string
    -a-a-a transformations to finite string inputs"

    YES!

    INCLUDING STATIC ANALYSIS.

    INCLUDING MATHEMATICAL PROOFS.

    INCLUDING THE DIAGONAL CONSTRUCTION.

    You have just restated a standard fact about computability and somehow convinced yourself it refutes computability theory.

    -a-a "The ultimate measure [...] is D simulated by H."

    NO.

    The ultimate criterion is whether D HALTS under its specified semantics.

    YOUR SIMULATOR IS NOT THE ARBITER OF MATHEMATICAL TRUTH.

    And you STILL haven't answered the question:

    When H rejects D, does that mean:

    - D DOES NOT HALT?
    - D IS INVALID?
    - H CANNOT DECIDE?

    PICK ONE.

    You have spent 22 years confusing a program's description, its
    execution, and your simulator's behavior.

    And you still cannot answer a three-choice question about your own algorithm.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 18:37:42 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "H(D) must take into account that
    D calls H(D) in recursive simulation."

    ONLY IF H WORKS BY RECURSIVE SIMULATION.

    FOR FUCK'S SAKE, HOW MANY TIMES MUST THIS BE EXPLAINED?

    The Halting Theorem does NOT require H to simulate D.

    It requires H to return a correct answer for every valid program.

    INCLUDING D.

    If H gets trapped in recursive simulation, H is not total.

    If H rejects D, you must explain what that rejection means.

    If H returns a halting verdict, diagonalization produces the
    contradiction.

    THERE IS NO FOURTH POSSIBILITY THAT INVALIDATES THE THEOREM.

    And once again, you have completely ignored my question.

    WHEN H REJECTS D, DOES IT MEAN:

    1. D does not halt?
    2. D is invalid?
    3. H cannot decide?

    PICK ONE, PETER.

    Stop hiding behind your simulator and ANSWER THE FUCKING QUESTION.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 12:52:39 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 12:37 PM, Python wrote:
    Peter,

    -a-a "H(D) must take into account that
    -a-a-a D calls H(D) in recursive simulation."

    ONLY IF H WORKS BY RECURSIVE SIMULATION.


    D simulated by H according to the operational semantics
    of the C/86 language is the ultimate basis of the behavior
    that D specifies AS AN INPUT TO H.

    H only applies finite string transformations to its
    actual static finite string inputs.

    FOR FUCK'S SAKE, HOW MANY TIMES MUST THIS BE EXPLAINED?

    The Halting Theorem does NOT require H to simulate D.

    It requires H to return a correct answer for every valid program.

    INCLUDING D.

    If H gets trapped in recursive simulation, H is not total.

    If H rejects D, you must explain what that rejection means.

    If H returns a halting verdict, diagonalization produces the contradiction.

    THERE IS NO FOURTH POSSIBILITY THAT INVALIDATES THE THEOREM.

    And once again, you have completely ignored my question.

    WHEN H REJECTS D, DOES IT MEAN:

    1. D does not halt?
    2. D is invalid?
    3. H cannot decide?

    PICK ONE, PETER.

    Stop hiding behind your simulator and ANSWER THE FUCKING QUESTION.
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 10:55:58 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/26 8:55 PM, dart200 wrote:
    On 11/12/26 12:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }

    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does
    _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is
    still not infinitely recursive it is actually just a simple non-
    terminating loop of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and
    classifying them the same

    how do u respond to this inconsistency polcott?

    polcott u still haven't responded to the fact HHH classifies both
    halting DD and non-halting DD2 into the same set of machines with the
    same semantic halting behavior...

    this is truly a 1 = 0 type of fault



    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated. HHH only actually demonstrates one
    step of recursion, not infinite. the infinite recursion only occurs
    if HHH doesn't break the invariant of letting the simulation run, but
    HHH does break that invariant, so invalidating the induction requires
    to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical" >>>>
    HHH violates the invariant so it violates it's own proof that DD is >>>>> recursive

    sipser said that same thing polcott








    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 13:03:24 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT
    correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
    of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial
    recursion is demonstrated. HHH only actually demonstrates one step of
    recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH
    does break that invariant, so invalidating the induction requires to
    prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott






    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 11:51:48 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code and nowhere does it mention HHH1. seriously bro i
    have poured over ur comments before and u not giving me the same respect
    back for literally 7 lines of code, 6 of which is urs i only changed one
    for DD2...

    my comment is that DD and DD2 are both classified as having the same
    semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a
    non-halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does
    _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is
    still not infinitely recursive it is actually just a simple non-
    terminating loop of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and
    classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated. HHH only actually demonstrates one
    step of recursion, not infinite. the infinite recursion only occurs
    if HHH doesn't break the invariant of letting the simulation run, but
    HHH does break that invariant, so invalidating the induction requires
    to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical" >>>>
    HHH violates the invariant so it violates it's own proof that DD is >>>>> recursive

    sipser said that same thing polcott








    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 13:56:23 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    and nowhere does it mention HHH1. seriously bro i
    have poured over ur comments before and u not giving me the same respect back for literally 7 lines of code, 6 of which is urs i only changed one
    for DD2...

    my comment is that DD and DD2 are both classified as having the same semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a non- halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
    makes the same decision to terminate and return 0, after which DD2
    does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2
    is still not infinitely recursive it is actually just a simple non-
    terminating loop of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and
    classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated. HHH only actually demonstrates
    one step of recursion, not infinite. the infinite recursion only
    occurs if HHH doesn't break the invariant of letting the simulation
    run, but HHH does break that invariant, so invalidating the
    induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a
    hypothetical"

    HHH violates the invariant so it violates it's own proof that DD
    is recursive

    sipser said that same thing polcott









    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 12:12:46 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/26 11:56 AM, olcott wrote:
    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    these are not analogous situations:

    HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders

    HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider

    right now ur claiming that HHH correctly classified halting machine DD
    and non-halting machine DD2 into the same semantic set without
    justifying how or why this ought to be so... or even acknowledging that
    it does so


    -aand nowhere does it mention HHH1. seriously bro i have poured over ur
    comments before and u not giving me the same respect back for
    literally 7 lines of code, 6 of which is urs i only changed one for
    DD2...

    my comment is that DD and DD2 are both classified as having the same
    semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a
    non- halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
    makes the same decision to terminate and return 0, after which DD2
    does _not_ halt, unlike DD1 which _does_ halt... but in this case
    DD2 is still not infinitely recursive it is actually just a simple
    non- terminating loop of one repeated state since that is the
    simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and
    classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated. HHH only actually demonstrates
    one step of recursion, not infinite. the infinite recursion only
    occurs if HHH doesn't break the invariant of letting the simulation >>>>> run, but HHH does break that invariant, so invalidating the
    induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a
    hypothetical"

    HHH violates the invariant so it violates it's own proof that DD >>>>>>> is recursive

    sipser said that same thing polcott











    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 14:19:14 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 2:12 PM, dart200 wrote:
    On 11/13/26 11:56 AM, olcott wrote:
    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>

    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    these are not analogous situations:

    HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders

    HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider

    right now ur claiming that HHH correctly classified halting machine DD
    and non-halting machine DD2 into the same semantic set without
    justifying how or why this ought to be so... or even acknowledging that
    it does so


    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.



    -aand nowhere does it mention HHH1. seriously bro i have poured over
    ur comments before and u not giving me the same respect back for
    literally 7 lines of code, 6 of which is urs i only changed one for
    DD2...

    my comment is that DD and DD2 are both classified as having the same
    semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a
    non- halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
    makes the same decision to terminate and return 0, after which DD2
    does _not_ halt, unlike DD1 which _does_ halt... but in this case
    DD2 is still not infinitely recursive it is actually just a simple
    non- terminating loop of one repeated state since that is the
    simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and >>>>> classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>> invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based >>>>>> on the invariant that HHH not cut DD simulation's short after the >>>>>> initial recursion is demonstrated. HHH only actually demonstrates >>>>>> one step of recursion, not infinite. the infinite recursion only
    occurs if HHH doesn't break the invariant of letting the
    simulation run, but HHH does break that invariant, so invalidating >>>>>> the induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a
    hypothetical"

    HHH violates the invariant so it violates it's own proof that DD >>>>>>>> is recursive

    sipser said that same thing polcott













    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 13:18:12 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/26 12:19 PM, olcott wrote:
    On 11/13/2026 2:12 PM, dart200 wrote:
    On 11/13/26 11:56 AM, olcott wrote:
    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions >>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    these are not analogous situations:

    HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders

    HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider

    right now ur claiming that HHH correctly classified halting machine DD
    and non-halting machine DD2 into the same semantic set without
    justifying how or why this ought to be so... or even acknowledging
    that it does so


    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.


    ok to clarify:

    HHH is _not_ a halting semantics decider,

    it's more of a "semantically grounded for halting semantics" decider?



    -aand nowhere does it mention HHH1. seriously bro i have poured over
    ur comments before and u not giving me the same respect back for
    literally 7 lines of code, 6 of which is urs i only changed one for
    DD2...

    my comment is that DD and DD2 are both classified as having the same
    semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a
    non- halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
    makes the same decision to terminate and return 0, after which DD2 >>>>>> does _not_ halt, unlike DD1 which _does_ halt... but in this case >>>>>> DD2 is still not infinitely recursive it is actually just a simple >>>>>> non- terminating loop of one repeated state since that is the
    simplest loop

    ur "decider" is equating the binary semantic halting behaviors of >>>>>> machine terminating machine DD and non-terminating machine DD2,
    and classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>>> invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical
    based on the invariant that HHH not cut DD simulation's short
    after the initial recursion is demonstrated. HHH only actually
    demonstrates one step of recursion, not infinite. the infinite
    recursion only occurs if HHH doesn't break the invariant of
    letting the simulation run, but HHH does break that invariant, so >>>>>>> invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a
    hypothetical"

    HHH violates the invariant so it violates it's own proof that >>>>>>>>> DD is recursive

    sipser said that same thing polcott














    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 15:31:22 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 3:18 PM, dart200 wrote:
    On 11/13/26 12:19 PM, olcott wrote:
    On 11/13/2026 2:12 PM, dart200 wrote:
    On 11/13/26 11:56 AM, olcott wrote:
    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
    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 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    these are not analogous situations:

    HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders

    HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider

    right now ur claiming that HHH correctly classified halting machine
    DD and non-halting machine DD2 into the same semantic set without
    justifying how or why this ought to be so... or even acknowledging
    that it does so


    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.


    ok to clarify:

    HHH is _not_ a halting semantics decider,

    it's more of a "semantically grounded for halting semantics" decider?


    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    That fits better under the same umbrella of how I
    generically handle all pathological self-reference.
    The Liar Paradox is proven to not be grounded in
    a truth value because it is semantically ill-formed.

    LP has the same infinitely recursive pattern as
    DD simulated by HHH. In both cases HHH and
    unify_with_occurs_check() see the pattern and
    cut it off.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 22:13:05 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "H only applies finite string transformations
    to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.

    It does NOT imply that H must simulate D.

    And your particular simulator does NOT define the semantics of D.

    You have now evaded the SAME QUESTION THREE TIMES.

    When H rejects D, does it mean:

    1. D does not halt?
    2. D is invalid?
    3. H cannot decide?

    PICK ONE.

    Your endless repetition about finite strings is not an answer.

    It is a smokescreen.

    After 22 years, surely you can explain what your own program's output
    means.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 15:51:15 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to something.

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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 14:58:58 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/26 2:13 PM, Python wrote:
    Peter,

    -a-a "H only applies finite string transformations
    -a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.

    It does NOT imply that H must simulate D.

    And your particular simulator does NOT define the semantics of D.

    You have now evaded the SAME QUESTION THREE TIMES.

    When H rejects D, does it mean:

    1. D does not halt?
    2. D is invalid?
    3. H cannot decide?

    PICK ONE.

    actually u can have a more advanced interface:

    1 => D halts
    0 => D does not halt OR is invalid/unrecognizable input to HHH

    i call this a partial recognizer. it also doesn't solve the halting
    problem but proving so is more involved that polcott will ever be


    Your endless repetition about finite strings is not an answer.

    It is a smokescreen.

    After 22 years, surely you can explain what your own program's output
    means.
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 17:15:16 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a "H only applies finite string transformations
    -a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.

    It does NOT imply that H must simulate D.


    No I have to add more steps to this so be able
    to see other aspects that are inherently required.

    I am only going to cover this one half step as
    soon as you accept this one half step we will move
    onto the other half of this same step.

    When I give you all the steps you reject them
    out-of-hand so we are down to 1/2 step at a time.

    And your particular simulator does NOT define the semantics of D.

    You have now evaded the SAME QUESTION THREE TIMES.

    When H rejects D, does it mean:

    1. D does not halt?
    2. D is invalid?
    3. H cannot decide?

    PICK ONE.

    Your endless repetition about finite strings is not an answer.

    It is a smokescreen.

    After 22 years, surely you can explain what your own program's output
    means.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 23:20:22 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    "Not with TMs."

    BULLSHIT.

    A Turing machine operates on finite symbols using a finite set of
    transition rules. Every finite computation can be described by finite
    symbolic transformations.

    Your distinction is imaginary.

    "As soon as you accept this one half step
    we will move onto the other half."

    ACCEPT WHAT, EXACTLY?

    You haven't stated a proposition that establishes anything about the
    Halting Theorem.

    And you STILL refuse to explain what H means when it rejects D.

    This is not a mathematical proof.

    It's a hostage negotiation conducted in half-steps.

    After 22 years of research, you apparently need my permission to finish a sentence.

    STATE YOUR CLAIM.

    DEFINE YOUR TERMS.

    ANSWER THE QUESTION.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 17:20:50 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    There is never any case where it is directly
    reporting on the actual behavior of any
    computation.

    A halt decider only ever reports on the
    result of a sequence of finite string
    transformations to finite string inputs.
    --
    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,comp.ai.philosophy on Fri Nov 13 17:24:27 2026
    From Newsgroup: comp.ai.philosophy


    context dishonestly erased.

    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a "Not with TMs."

    BULLSHIT.

    A Turing machine operates on finite symbols using a finite set of
    transition rules. Every finite computation can be described by finite symbolic transformations.

    Your distinction is imaginary.

    -a-a "As soon as you accept this one half step
    -a-a-a we will move onto the other half."

    ACCEPT WHAT, EXACTLY?

    You haven't stated a proposition that establishes anything about the
    Halting Theorem.

    And you STILL refuse to explain what H means when it rejects D.

    This is not a mathematical proof.

    It's a hostage negotiation conducted in half-steps.

    After 22 years of research, you apparently need my permission to finish
    a sentence.

    STATE YOUR CLAIM.

    DEFINE YOUR TERMS.

    ANSWER THE QUESTION.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 23:27:05 2026
    From Newsgroup: comp.ai.philosophy

    Le 14/11/2026 |a 00:15, olcott a |-crit :
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a "H only applies finite string transformations
    -a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.

    It does NOT imply that H must simulate D.


    No I have to add more steps to this so be able
    to see other aspects that are inherently required.

    I am only going to cover this one half step as
    soon as you accept this one half step we will move
    onto the other half of this same step.

    Peter,

    "Not with TMs."

    BULLSHIT.

    A Turing machine operates on finite symbols using a finite set of
    transition rules. Every finite computation can be described by finite
    symbolic transformations.

    Your distinction is imaginary.

    "As soon as you accept this one half step
    we will move onto the other half."

    ACCEPT WHAT, EXACTLY?

    You haven't stated a proposition that establishes anything about the
    Halting Theorem.

    And you STILL refuse to explain what H means when it rejects D.

    This is not a mathematical proof.

    It's a hostage negotiation conducted in half-steps.

    After 22 years of research, you apparently need my permission to finish a sentence.

    STATE YOUR CLAIM.

    DEFINE YOUR TERMS.

    ANSWER THE QUESTION.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 17:36:13 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 5:27 PM, Python wrote:
    Le 14/11/2026 |a 00:15, olcott a |-crit :
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a "H only applies finite string transformations
    -a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.

    It does NOT imply that H must simulate D.


    No I have to add more steps to this so be able
    to see other aspects that are inherently required.

    I am only going to cover this one half step as
    soon as you accept this one half step we will move
    onto the other half of this same step.

    Peter,

    -a-a "Not with TMs."


    Do not reply to this message as a reply
    to the message where you dishonestly erased
    the context. Go back to that prior message
    and do not erase the context this time.

    BULLSHIT.

    A Turing machine operates on finite symbols using a finite set of
    transition rules. Every finite computation can be described by finite symbolic transformations.

    Your distinction is imaginary.

    -a-a "As soon as you accept this one half step
    -a-a-a we will move onto the other half."

    ACCEPT WHAT, EXACTLY?

    You haven't stated a proposition that establishes anything about the
    Halting Theorem.

    And you STILL refuse to explain what H means when it rejects D.

    This is not a mathematical proof.

    It's a hostage negotiation conducted in half-steps.

    After 22 years of research, you apparently need my permission to finish
    a sentence.

    STATE YOUR CLAIM.

    DEFINE YOUR TERMS.

    ANSWER THE QUESTION.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 23:43:25 2026
    From Newsgroup: comp.ai.philosophy

    Le 14/11/2026 |a 00:36, olcott a |-crit :
    On 11/13/2026 5:27 PM, Python wrote:
    Le 14/11/2026 |a 00:15, olcott a |-crit :
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a "H only applies finite string transformations
    -a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.

    It does NOT imply that H must simulate D.


    No I have to add more steps to this so be able
    to see other aspects that are inherently required.

    I am only going to cover this one half step as
    soon as you accept this one half step we will move
    onto the other half of this same step.

    Peter,

    -a-a "Not with TMs."


    Do not reply to this message as a reply
    to the message where you dishonestly erased
    the context. Go back to that prior message
    and do not erase the context this time.

    There were no contexte to erase. The dishonesty is yours.

    BULLSHIT.

    "Not with TMs." is the worse bullshit you've ever post.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 17:49:15 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    "H only applies finite string transformations
    to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 15:51:38 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/26 3:27 PM, Python wrote:
    Le 14/11/2026 |a 00:15, olcott a |-crit :
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a "H only applies finite string transformations
    -a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.

    It does NOT imply that H must simulate D.


    No I have to add more steps to this so be able
    to see other aspects that are inherently required.

    I am only going to cover this one half step as
    soon as you accept this one half step we will move
    onto the other half of this same step.

    Peter,

    -a-a "Not with TMs."

    BULLSHIT.

    A Turing machine operates on finite symbols using a finite set of
    transition rules. Every finite computation can be described by finite symbolic transformations.

    truth

    tm definition are a set of instructions for doing a series of finite
    string transformations, specifically one symbol a time


    Your distinction is imaginary.

    -a-a "As soon as you accept this one half step
    -a-a-a we will move onto the other half."

    ACCEPT WHAT, EXACTLY?

    You haven't stated a proposition that establishes anything about the
    Halting Theorem.

    And you STILL refuse to explain what H means when it rejects D.

    This is not a mathematical proof.

    It's a hostage negotiation conducted in half-steps.

    After 22 years of research, you apparently need my permission to finish
    a sentence.

    STATE YOUR CLAIM.

    DEFINE YOUR TERMS.

    ANSWER THE QUESTION.
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 16:57:22 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to exist, answers a question about a specific computation. There are no 'proxies' involved

    There is never any case where it is directly
    reporting on the actual behavior of any
    computation.

    Nonsense. That's what a halt decider is defined to do. I know that you
    have your various weird notions about what is and what is not within the 'scope' of computations, but those notions don't correspond to reality,
    and certainly don't match up with anything people actually working on computability theory claim.

    A halt decider only ever reports on the
    result of a sequence of finite string
    transformations to finite string inputs.

    And finite strings are perfectly capable of representing actual
    computations, along with many other things.

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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 00:04:40 2026
    From Newsgroup: comp.ai.philosophy

    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    "H only applies finite string transformations
    to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    No, there are not.

    No, there are not.

    No, there are not.

    No, there are not.

    See? I can repeat an assertion five times too.

    IT STILL DOESN'T MAKE IT TRUE.

    A Turing machine has a finite set of states, a finite tape alphabet, and a finite transition table.

    THAT'S ABOUT AS MINIMAL AS A COMPUTATIONAL MODEL GETS.

    The implementation details are precisely what the model abstracts away.

    And repeating your nonsense instead of defending it is not an argument.

    It's a broken record.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 18:03:54 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to exist, answers a question about a specific computation. There are no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.
    --
    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 17:16:58 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to something. >>>>
    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to
    exist, answers a question about a specific computation. There are no
    'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a decider somehow addresses any of my points.

    And the second paragraph above is entirely incoherent. It's not even a complete sentence. When copying and pasting at least make sure you've
    copied the phrase you intended to copy.

    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 comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 18:18:19 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations
    -a-a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    No tape_head moves, no read tape element write
    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.
    --
    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,comp.ai.philosophy on Fri Nov 13 18:23:15 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to
    something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to
    exist, answers a question about a specific computation. There are no
    'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine machine behavior. We can at best indirectly examine machine behavior through
    finite string proxies that encode sequences of steps.

    And the second paragraph above is entirely incoherent. It's not even a complete sentence. When copying and pasting at least make sure you've
    copied the phrase you intended to copy.

    Andr|-


    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 00:28:54 2026
    From Newsgroup: comp.ai.philosophy

    Le 14/11/2026 |a 01:18, olcott a |-crit :
    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations
    -a-a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    No tape_head moves, no read tape element write
    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.

    Peter,

    "So you never heard of move tape_head left?"

    FOR FUCK'S SAKE.

    Yes, Peter. A Turing machine has a tape head.

    A C program has variables.

    A lambda calculus expression has beta-reductions.

    A string rewriting system has rewriting rules.

    CONGRATULATIONS.

    YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE DIFFERENT PRIMITIVES.

    That is precisely why we study their computational equivalence.

    "When we get rid of these implementation details
    thenn (then and only then) can we focus..."

    NO.

    Removing the tape head does not magically reveal new laws of
    computability.

    It merely replaces one Turing-complete formalism with another.

    And any universal halting decider in your favorite string rewriting
    formalism would yield one for Turing machines.

    WHICH DIAGONALIZATION RULES OUT.

    After 22 years, you are still mistaking a change of notation for a mathematical breakthrough.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 17:37:30 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to
    something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to
    exist, answers a question about a specific computation. There are no
    'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a
    decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine machine behavior. We can at best indirectly examine machine behavior through
    finite string proxies that encode sequences of steps.

    You are seriously confused. whether +u* mentions strings, machines,
    integers, etc. is entirely irrelevant. A string is a completely *uninterpreted* sequence of symbols. As soon as you start talking about
    a string 'that encodes a sequence of steps' you are no longer talking
    about a pure string. You are talking about a string that *represents* something else, and the question being posed to your decider is about
    that something else.

    Halt deciders ask about computations, not strings. Because of the nature
    of Turing Machines, those computations must be encoded as strings, but
    the question the decider asks is not about the string; it is about the
    thing represented by the string.


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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 16:37:40 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/26 4:18 PM, olcott wrote:
    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations
    -a-a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    lol, moving the tape is just a method to mechanically select where the
    next change will take place polcott...


    No tape_head moves, no read tape element write

    so method to select how the next is determined?

    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.

    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 18:40:05 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 6:28 PM, Python wrote:
    Le 14/11/2026 |a 01:18, olcott a |-crit :
    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations
    -a-a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    No tape_head moves, no read tape element write
    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.

    Peter,

    -a-a "So you never heard of move tape_head left?"

    FOR FUCK'S SAKE.

    Yes, Peter. A Turing machine has a tape head.

    A C program has variables.

    A lambda calculus expression has beta-reductions.

    A string rewriting system has rewriting rules.

    CONGRATULATIONS.

    YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE DIFFERENT PRIMITIVES.

    That is precisely why we study their computational equivalence.

    -a-a "When we get rid of these implementation details
    -a-a-a thenn (then and only then) can we focus..."

    NO.

    Removing the tape head does not magically reveal new laws of computability.

    It merely replaces one Turing-complete formalism with another.

    And any universal halting decider in your favorite string rewriting formalism would yield one for Turing machines.

    WHICH DIAGONALIZATION RULES OUT.

    After 22 years, you are still mistaking a change of notation for a mathematical breakthrough.


    When we look at this through the simplest most
    generic abstraction of finite string transformations
    to INPUT finite strings thenn (then and only then)

    we can begin to look deeper into what categories
    of finite string transformations are specifically
    relevant to specific decision criteria.

    strcmp() must compare strings
    halt deciders must examine behavior
    --
    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,comp.ai.philosophy on Fri Nov 13 18:48:42 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to
    something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to
    exist, answers a question about a specific computation. There are
    no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a
    decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine machine
    behavior. We can at best indirectly examine machine behavior through
    finite string proxies that encode sequences of steps.

    You are seriously confused. whether +u* mentions strings, machines, integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    We cannot move on to any other points until after
    you understand this.

    A string is a completely
    *uninterpreted* sequence of symbols. As soon as you start talking about
    a string 'that encodes a sequence of steps' you are no longer talking
    about a pure string. You are talking about a string that *represents* something else, and the question being posed to your decider is about
    that something else.

    Halt deciders ask about computations, not strings. Because of the nature
    of Turing Machines, those computations must be encoded as strings, but
    the question the decider asks is not about the string; it is about the
    thing represented by the string.


    Andr|-


    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 16:50:57 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/26 4:48 PM, olcott wrote:
    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to
    something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to
    exist, answers a question about a specific computation. There are >>>>>> no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a
    decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine machine
    behavior. We can at best indirectly examine machine behavior through
    finite string proxies that encode sequences of steps.

    You are seriously confused. whether +u* mentions strings, machines,
    integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    ... the halt decision is in respect to the behavior of the machine
    defined by the string ...


    We cannot move on to any other points until after
    you understand this.

    A string is a completely *uninterpreted* sequence of symbols. As soon
    as you start talking about a string 'that encodes a sequence of steps'
    you are no longer talking about a pure string. You are talking about a
    string that *represents* something else, and the question being posed
    to your decider is about that something else.

    Halt deciders ask about computations, not strings. Because of the
    nature of Turing Machines, those computations must be encoded as
    strings, but the question the decider asks is not about the string; it
    is about the thing represented by the string.


    Andr|-




    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 01:01:46 2026
    From Newsgroup: comp.ai.philosophy

    Le 14/11/2026 |a 01:40, olcott a |-crit :
    On 11/13/2026 6:28 PM, Python wrote:
    Le 14/11/2026 |a 01:18, olcott a |-crit :
    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations
    -a-a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    No tape_head moves, no read tape element write
    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.

    Peter,

    -a-a "So you never heard of move tape_head left?"

    FOR FUCK'S SAKE.

    Yes, Peter. A Turing machine has a tape head.

    A C program has variables.

    A lambda calculus expression has beta-reductions.

    A string rewriting system has rewriting rules.

    CONGRATULATIONS.

    YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE DIFFERENT
    PRIMITIVES.

    That is precisely why we study their computational equivalence.

    -a-a "When we get rid of these implementation details
    -a-a-a thenn (then and only then) can we focus..."

    NO.

    Removing the tape head does not magically reveal new laws of computability. >>
    It merely replaces one Turing-complete formalism with another.

    And any universal halting decider in your favorite string rewriting
    formalism would yield one for Turing machines.

    WHICH DIAGONALIZATION RULES OUT.

    After 22 years, you are still mistaking a change of notation for a
    mathematical breakthrough.


    When we look at this through the simplest most
    generic abstraction of finite string transformations
    to INPUT finite strings thenn (then and only then)

    we can begin to look deeper into what categories
    of finite string transformations are specifically
    relevant to specific decision criteria.

    strcmp() must compare strings
    halt deciders must examine behavior

    Peter,

    "strcmp() must compare strings
    halt deciders must examine behavior"

    FOR FUCK'S SAKE.

    A halting decider must DETERMINE WHETHER A PROGRAM HALTS.

    That is its specification.

    HOW it determines the answer is an implementation detail.

    You have now invented:

    Decider(Olcott)
    Halt Decider(Olcott)

    CONGRATULATIONS.

    You are perfectly free to define your own restricted class of algorithms.

    But you cannot redefine "halting decider", impose your favorite simulation requirements, and then claim to have refuted a theorem about ALL
    computable halting deciders.

    THAT IS NOT MATHEMATICS.

    THAT IS CHANGING THE SUBJECT.

    Your alleged "inherent requirement" is precisely what you need to PROVE.

    Instead, you simply insert it into your definition.

    And your reference to Post canonical systems changes nothing.

    They are Turing-equivalent.

    THEREFORE DIAGONALIZATION APPLIES TO THEM TOO.

    You have not discovered a loophole in the Halting Theorem.

    You have invented a new vocabulary for misunderstanding it.

    And you STILL haven't answered what H returns when it rejects D.

    After 28 years, perhaps it is time to stop redefining the question and
    start answering one.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 19:02:35 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 6:50 PM, dart200 wrote:
    On 11/13/26 4:48 PM, olcott wrote:
    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>> something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to >>>>>>> exist, answers a question about a specific computation. There are >>>>>>> no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a
    decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine
    machine behavior. We can at best indirectly examine machine behavior
    through finite string proxies that encode sequences of steps.

    You are seriously confused. whether +u* mentions strings, machines,
    integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    ... the halt decision is in respect to the behavior of the machine
    defined by the string ...


    That has ALWAYS been counter-factual
    and can only be seen as counter-factual
    when one pays enormously more attention
    to the actual details than anyone has
    ever paid before.
    --
    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,comp.ai.philosophy on Fri Nov 13 19:10:18 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 7:01 PM, Python wrote:
    Le 14/11/2026 |a 01:40, olcott a |-crit :
    On 11/13/2026 6:28 PM, Python wrote:
    Le 14/11/2026 |a 01:18, olcott a |-crit :
    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations
    -a-a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    No tape_head moves, no read tape element write
    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.

    Peter,

    -a-a-a "So you never heard of move tape_head left?"

    FOR FUCK'S SAKE.

    Yes, Peter. A Turing machine has a tape head.

    A C program has variables.

    A lambda calculus expression has beta-reductions.

    A string rewriting system has rewriting rules.

    CONGRATULATIONS.

    YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
    DIFFERENT PRIMITIVES.

    That is precisely why we study their computational equivalence.

    -a-a-a "When we get rid of these implementation details
    -a-a-a-a thenn (then and only then) can we focus..."

    NO.

    Removing the tape head does not magically reveal new laws of
    computability.

    It merely replaces one Turing-complete formalism with another.

    And any universal halting decider in your favorite string rewriting
    formalism would yield one for Turing machines.

    WHICH DIAGONALIZATION RULES OUT.

    After 22 years, you are still mistaking a change of notation for a
    mathematical breakthrough.


    When we look at this through the simplest most
    generic abstraction of finite string transformations
    to INPUT finite strings thenn (then and only then)

    we can begin to look deeper into what categories
    of finite string transformations are specifically
    relevant to specific decision criteria.

    strcmp() must compare strings
    halt deciders must examine behavior

    Peter,

    -a-a "strcmp() must compare strings
    -a-a-a halt deciders must examine behavior"

    FOR FUCK'S SAKE.

    A halting decider must DETERMINE WHETHER A PROGRAM HALTS.

    That is its specification.

    HOW it determines the answer is an [MANDATORY] implementation detail.


    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    --
    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 =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 18:21:35 2026
    From Newsgroup: comp.ai.philosophy

    On 2026-11-13 17:48, olcott wrote:
    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to
    something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to
    exist, answers a question about a specific computation. There are >>>>>> no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a
    decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine machine
    behavior. We can at best indirectly examine machine behavior through
    finite string proxies that encode sequences of steps.

    You are seriously confused. whether +u* mentions strings, machines,
    integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    No. That is simply a statement reflecting your disconnect from reality.
    Finite strings can represent any number of things, including
    computations. I've given you examples in the past which you have
    ignored. For example, is the string '10' even or odd? Answer. It's not
    even a coherent question. Evenness is a property of natural numbers, not strings. Yet the evenness of a number is perfectly computable.

    We cannot move on to any other points until after
    you understand this.

    You present a claim which is patently false and then claim we cannot
    'move on' until I accept your point. That's not going to happen. Your
    point is simply wrong.

    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 comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 19:41:43 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 7:21 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:48, olcott wrote:
    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>> something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to >>>>>>> exist, answers a question about a specific computation. There are >>>>>>> no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a
    decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine
    machine behavior. We can at best indirectly examine machine behavior
    through finite string proxies that encode sequences of steps.

    You are seriously confused. whether +u* mentions strings, machines,
    integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    No. That is simply a statement reflecting your disconnect from reality. Finite strings can represent any number of things, including
    computations.

    And the false assumption is the this representation
    is the same behavior as the behavior of the input
    to H(D) is empirically proven false yet you do not
    give a rat's ass for truth you only care about rebuttal.

    I've given you examples in the past which you have
    ignored. For example, is the string '10' even or odd? Answer. It's not
    even a coherent question. Evenness is a property of natural numbers, not strings. Yet the evenness of a number is perfectly computable.

    We cannot move on to any other points until after
    you understand this.

    You present a claim which is patently false and then claim we cannot
    'move on' until I accept your point. That's not going to happen. Your
    point is simply wrong.

    Andr|-

    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 20:19:29 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/26 5:02 PM, olcott wrote:
    On 11/13/2026 6:50 PM, dart200 wrote:
    On 11/13/26 4:48 PM, olcott wrote:
    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>>> something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things to >>>>>>>> exist, answers a question about a specific computation. There >>>>>>>> are no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a
    decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine
    machine behavior. We can at best indirectly examine machine
    behavior through finite string proxies that encode sequences of steps. >>>>
    You are seriously confused. whether +u* mentions strings, machines,
    integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    ... the halt decision is in respect to the behavior of the machine
    defined by the string ...


    That has ALWAYS been counter-factual
    and can only be seen as counter-factual
    when one pays enormously more attention
    to the actual details than anyone has
    ever paid before.


    lol, polcott what does "counter-factual" mean to you?
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 23:02:23 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 10:19 PM, dart200 wrote:
    On 11/13/26 5:02 PM, olcott wrote:
    On 11/13/2026 6:50 PM, dart200 wrote:
    On 11/13/26 4:48 PM, olcott wrote:
    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>>>> something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things >>>>>>>>> to exist, answers a question about a specific computation.
    There are no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting


    I have absolutely no idea why you think giving a definition of a >>>>>>> decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine
    machine behavior. We can at best indirectly examine machine
    behavior through finite string proxies that encode sequences of
    steps.

    You are seriously confused. whether +u* mentions strings, machines, >>>>> integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    ... the halt decision is in respect to the behavior of the machine
    defined by the string ...


    That has ALWAYS been counter-factual
    and can only be seen as counter-factual
    when one pays enormously more attention
    to the actual details than anyone has
    ever paid before.


    lol, polcott what does "counter-factual" mean to you?


    PROVEN FALSE ON THE BASIS OF ITS MEANING.
    The behavior of x(y) is specified by the
    input to H(x,y) ONLY when x does not call H(x,y).
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Fri Nov 13 22:55:53 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/26 9:02 PM, olcott wrote:
    On 11/13/2026 10:19 PM, dart200 wrote:
    On 11/13/26 5:02 PM, olcott wrote:
    On 11/13/2026 6:50 PM, dart200 wrote:
    On 11/13/26 4:48 PM, olcott wrote:
    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H) >>>>>>>>>>>>> Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    Either DD halts or it doesn't. It doesn't halt "relative" to >>>>>>>>>>>> something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things >>>>>>>>>> to exist, answers a question about a specific computation. >>>>>>>>>> There are no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting >>>>>>>>

    I have absolutely no idea why you think giving a definition of a >>>>>>>> decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine
    machine behavior. We can at best indirectly examine machine
    behavior through finite string proxies that encode sequences of >>>>>>> steps.

    You are seriously confused. whether +u* mentions strings, machines, >>>>>> integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    ... the halt decision is in respect to the behavior of the machine
    defined by the string ...


    That has ALWAYS been counter-factual
    and can only be seen as counter-factual
    when one pays enormously more attention
    to the actual details than anyone has
    ever paid before.


    lol, polcott what does "counter-factual" mean to you?


    PROVEN FALSE ON THE BASIS OF ITS MEANING.

    that's not what a counter-factual is:

    a counter-factual is a hypothetical implication based on a false premise

    The behavior of x(y) is specified by the
    input to H(x,y) ONLY when x does not call H(x,y).


    ironically HHH(DD)->0 is based on the counter-factual reasoning that if
    HHH had let DD run, then it would be non-terminating

    this is counterfactual because clearly HHH does not let DD run forever,
    it cuts off the simulation of DD in order to return 0
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 10:53:18 2026
    From Newsgroup: comp.ai.philosophy

    Le 14/11/2026 |a 02:10, olcott a |-crit :
    On 11/13/2026 7:01 PM, Python wrote:
    Le 14/11/2026 |a 01:40, olcott a |-crit :
    On 11/13/2026 6:28 PM, Python wrote:
    Le 14/11/2026 |a 01:18, olcott a |-crit :
    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations
    -a-a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    No tape_head moves, no read tape element write
    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.

    Peter,

    -a-a-a "So you never heard of move tape_head left?"

    FOR FUCK'S SAKE.

    Yes, Peter. A Turing machine has a tape head.

    A C program has variables.

    A lambda calculus expression has beta-reductions.

    A string rewriting system has rewriting rules.

    CONGRATULATIONS.

    YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
    DIFFERENT PRIMITIVES.

    That is precisely why we study their computational equivalence.

    -a-a-a "When we get rid of these implementation details
    -a-a-a-a thenn (then and only then) can we focus..."

    NO.

    Removing the tape head does not magically reveal new laws of
    computability.

    It merely replaces one Turing-complete formalism with another.

    And any universal halting decider in your favorite string rewriting
    formalism would yield one for Turing machines.

    WHICH DIAGONALIZATION RULES OUT.

    After 22 years, you are still mistaking a change of notation for a
    mathematical breakthrough.


    When we look at this through the simplest most
    generic abstraction of finite string transformations
    to INPUT finite strings thenn (then and only then)

    we can begin to look deeper into what categories
    of finite string transformations are specifically
    relevant to specific decision criteria.

    strcmp() must compare strings
    halt deciders must examine behavior

    Peter,

    -a-a "strcmp() must compare strings
    -a-a-a halt deciders must examine behavior"

    FOR FUCK'S SAKE.

    A halting decider must DETERMINE WHETHER A PROGRAM HALTS.

    That is its specification.

    HOW it determines the answer is an [MANDATORY] implementation detail.


    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.

    Peter,

    YOU HAVE JUST FALSIFIED MY WORDS.

    I wrote:

    "HOW it determines the answer is an
    implementation detail."

    You quoted me as writing:

    "HOW it determines the answer is an
    [MANDATORY] implementation detail."

    I DID NOT WRITE "[MANDATORY]".

    YOU INSERTED IT.

    And that insertion changes the meaning of my statement.

    You also deleted virtually my entire argument, including the questions you have repeatedly refused to answer.

    Trimming quotations is normal.

    ALTERING SOMEONE ELSE'S WORDS TO MAKE THEM SAY SOMETHING DIFFERENT IS NOT.

    And then you repeat:

    "To fully understand what the Hell is
    actually going on."

    FIVE TIMES.

    Well, Peter, here's something you should understand:

    YOU DO NOT GET TO REWRITE MY ARGUMENT AND THEN PRETEND I MADE YOURS.

    You have repeatedly accused others of dishonesty.

    NOW LOOK AT WHAT YOU JUST DID.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 06:52:59 2026
    From Newsgroup: comp.ai.philosophy

    On 11/14/2026 12:55 AM, dart200 wrote:
    On 11/13/26 9:02 PM, olcott wrote:
    On 11/13/2026 10:19 PM, dart200 wrote:
    On 11/13/26 5:02 PM, olcott wrote:
    On 11/13/2026 6:50 PM, dart200 wrote:
    On 11/13/26 4:48 PM, olcott wrote:
    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H) >>>>>>>>>>>>>> Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH. >>>>>>>>>>>>>
    Either DD halts or it doesn't. It doesn't halt "relative" >>>>>>>>>>>>> to something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such things >>>>>>>>>>> to exist, answers a question about a specific computation. >>>>>>>>>>> There are no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty >>>>>>>>>> string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting >>>>>>>>>

    I have absolutely no idea why you think giving a definition of >>>>>>>>> a decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine >>>>>>>> machine behavior. We can at best indirectly examine machine
    behavior through finite string proxies that encode sequences of >>>>>>>> steps.

    You are seriously confused. whether +u* mentions strings,
    machines, integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    ... the halt decision is in respect to the behavior of the machine
    defined by the string ...


    That has ALWAYS been counter-factual
    and can only be seen as counter-factual
    when one pays enormously more attention
    to the actual details than anyone has
    ever paid before.


    lol, polcott what does "counter-factual" mean to you?


    PROVEN FALSE ON THE BASIS OF ITS MEANING.

    that's not what a counter-factual is:


    I am stipulating that it what I mean.
    3 > 5 is counter-factual.

    a counter-factual is a hypothetical implication based on a false premise

    The behavior of x(y) is specified by the
    input to H(x,y) ONLY when x does not call H(x,y).


    ironically HHH(DD)->0 is based on the counter-factual reasoning that if
    HHH had let DD run, then it would be non-terminating


    Halt deciders are only accountable for determining
    the behavior that their input finite string specifies.

    this is counterfactual because clearly HHH does not let DD run forever,
    it cuts off the simulation of DD in order to return 0


    The same way that it would for an infinite loop, stupid.
    --
    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,comp.ai.philosophy on Sat Nov 14 08:36:43 2026
    From Newsgroup: comp.ai.philosophy

    On 11/14/2026 4:53 AM, Python wrote:
    Le 14/11/2026 |a 02:10, olcott a |-crit :
    On 11/13/2026 7:01 PM, Python wrote:
    Le 14/11/2026 |a 01:40, olcott a |-crit :
    On 11/13/2026 6:28 PM, Python wrote:
    Le 14/11/2026 |a 01:18, olcott a |-crit :
    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations
    -a-a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    No tape_head moves, no read tape element write
    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.

    Peter,

    -a-a-a "So you never heard of move tape_head left?"

    FOR FUCK'S SAKE.

    Yes, Peter. A Turing machine has a tape head.

    A C program has variables.

    A lambda calculus expression has beta-reductions.

    A string rewriting system has rewriting rules.

    CONGRATULATIONS.

    YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
    DIFFERENT PRIMITIVES.

    That is precisely why we study their computational equivalence.

    -a-a-a "When we get rid of these implementation details
    -a-a-a-a thenn (then and only then) can we focus..."

    NO.

    Removing the tape head does not magically reveal new laws of
    computability.

    It merely replaces one Turing-complete formalism with another.

    And any universal halting decider in your favorite string rewriting >>>>> formalism would yield one for Turing machines.

    WHICH DIAGONALIZATION RULES OUT.

    After 22 years, you are still mistaking a change of notation for a
    mathematical breakthrough.


    When we look at this through the simplest most
    generic abstraction of finite string transformations
    to INPUT finite strings thenn (then and only then)

    we can begin to look deeper into what categories
    of finite string transformations are specifically
    relevant to specific decision criteria.

    strcmp() must compare strings
    halt deciders must examine behavior

    Peter,

    -a-a-a "strcmp() must compare strings
    -a-a-a-a halt deciders must examine behavior"

    FOR FUCK'S SAKE.

    A halting decider must DETERMINE WHETHER A PROGRAM HALTS.

    That is its specification.

    HOW it determines the answer is an [MANDATORY] implementation detail.


    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.

    Peter,

    YOU HAVE JUST FALSIFIED MY WORDS.

    I wrote:

    -a-a "HOW it determines the answer is an
    -a-a-a implementation detail."

    You quoted me as writing:

    -a-a "HOW it determines the answer is an
    -a-a-a [MANDATORY] implementation detail."

    I DID NOT WRITE "[MANDATORY]".

    YOU INSERTED IT.

    And that insertion changes the meaning of my statement.


    Yes and I used standard syntax to indicate that it was inserted.

    You also deleted virtually my entire argument, including the questions
    you have repeatedly refused to answer.

    Trimming quotations is normal.

    ALTERING SOMEONE ELSE'S WORDS TO MAKE THEM SAY SOMETHING DIFFERENT IS NOT.

    And then you repeat:

    -a-a "To fully understand what the Hell is
    -a-a-a actually going on."

    FIVE TIMES.


    You seem to have a great difficulty paying close attention.
    Richard says that he has ADD and the repetition did help
    him focus.

    Well, Peter, here's something you should understand:

    YOU DO NOT GET TO REWRITE MY ARGUMENT AND THEN PRETEND I MADE YOURS.

    You have repeatedly accused others of dishonesty.

    NOW LOOK AT WHAT YOU JUST DID.


    I used standard syntax to indicate that [MANDATORY] was inserted.
    I used standard syntax to indicate that [MANDATORY] was inserted.
    I used standard syntax to indicate that [MANDATORY] was inserted.
    I used standard syntax to indicate that [MANDATORY] was inserted.

    In order to deeply understand what the Hell is going
    on implementation details must be addressed at some
    level of abstraction.

    By applying finite string transformation rules to finite
    string inputs to derive any and all outputs.
    We see two things:

    (1) Any result that cannot be derived this way is outside
    the scope of Turing commutable functions the same way that
    filling your tires with air is outside the scope of your
    toaster.

    (2) Within this simplest Turing equivalent model of
    computation we can examine the notion of deciders more
    deeply.

    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    All non-trivial deciders must inherently apply finite string
    transformations that are relevant to their decision criteria.

    All halt deciders must inherently apply finite string
    transformations that are relevant to the behavior specified
    by their input finite string.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 14:49:50 2026
    From Newsgroup: comp.ai.philosophy

    Le 14/11/2026 |a 15:36, olcott a |-crit :
    On 11/14/2026 4:53 AM, Python wrote:
    Le 14/11/2026 |a 02:10, olcott a |-crit :
    On 11/13/2026 7:01 PM, Python wrote:
    Le 14/11/2026 |a 01:40, olcott a |-crit :
    On 11/13/2026 6:28 PM, Python wrote:
    Le 14/11/2026 |a 01:18, olcott a |-crit :
    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations
    -a-a-a-a-a to its actual static finite string inputs."

    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    No tape_head moves, no read tape element write
    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.

    Peter,

    -a-a-a "So you never heard of move tape_head left?"

    FOR FUCK'S SAKE.

    Yes, Peter. A Turing machine has a tape head.

    A C program has variables.

    A lambda calculus expression has beta-reductions.

    A string rewriting system has rewriting rules.

    CONGRATULATIONS.

    YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
    DIFFERENT PRIMITIVES.

    That is precisely why we study their computational equivalence.

    -a-a-a "When we get rid of these implementation details
    -a-a-a-a thenn (then and only then) can we focus..."

    NO.

    Removing the tape head does not magically reveal new laws of
    computability.

    It merely replaces one Turing-complete formalism with another.

    And any universal halting decider in your favorite string rewriting >>>>>> formalism would yield one for Turing machines.

    WHICH DIAGONALIZATION RULES OUT.

    After 22 years, you are still mistaking a change of notation for a >>>>>> mathematical breakthrough.


    When we look at this through the simplest most
    generic abstraction of finite string transformations
    to INPUT finite strings thenn (then and only then)

    we can begin to look deeper into what categories
    of finite string transformations are specifically
    relevant to specific decision criteria.

    strcmp() must compare strings
    halt deciders must examine behavior

    Peter,

    -a-a-a "strcmp() must compare strings
    -a-a-a-a halt deciders must examine behavior"

    FOR FUCK'S SAKE.

    A halting decider must DETERMINE WHETHER A PROGRAM HALTS.

    That is its specification.

    HOW it determines the answer is an [MANDATORY] implementation detail.


    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.

    Peter,

    YOU HAVE JUST FALSIFIED MY WORDS.

    I wrote:

    -a-a "HOW it determines the answer is an
    -a-a-a implementation detail."

    You quoted me as writing:

    -a-a "HOW it determines the answer is an
    -a-a-a [MANDATORY] implementation detail."

    I DID NOT WRITE "[MANDATORY]".

    YOU INSERTED IT.

    And that insertion changes the meaning of my statement.


    Yes and I used standard syntax to indicate that it was inserted.

    You also deleted virtually my entire argument, including the questions
    you have repeatedly refused to answer.

    Trimming quotations is normal.

    ALTERING SOMEONE ELSE'S WORDS TO MAKE THEM SAY SOMETHING DIFFERENT IS NOT. >>
    And then you repeat:

    -a-a "To fully understand what the Hell is
    -a-a-a actually going on."

    FIVE TIMES.


    You seem to have a great difficulty paying close attention.
    Richard says that he has ADD and the repetition did help
    him focus.

    Well, Peter, here's something you should understand:

    YOU DO NOT GET TO REWRITE MY ARGUMENT AND THEN PRETEND I MADE YOURS.

    You have repeatedly accused others of dishonesty.

    NOW LOOK AT WHAT YOU JUST DID.


    I used standard syntax to indicate that [MANDATORY] was inserted.
    I used standard syntax to indicate that [MANDATORY] was inserted.
    I used standard syntax to indicate that [MANDATORY] was inserted.
    I used standard syntax to indicate that [MANDATORY] was inserted.

    In order to deeply understand what the Hell is going
    on implementation details must be addressed at some
    level of abstraction.

    By applying finite string transformation rules to finite
    string inputs to derive any and all outputs.
    We see two things:

    (1) Any result that cannot be derived this way is outside
    the scope of Turing commutable functions the same way that
    filling your tires with air is outside the scope of your
    toaster.

    (2) Within this simplest Turing equivalent model of
    computation we can examine the notion of deciders more
    deeply.

    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    All non-trivial deciders must inherently apply finite string
    transformations that are relevant to their decision criteria.

    All halt deciders must inherently apply finite string
    transformations that are relevant to the behavior specified
    by their input finite string.

    Peter,

    "I used standard syntax to indicate that
    [MANDATORY] was inserted."

    Yes, the brackets indicate an editorial insertion.

    They do NOT give you permission to insert a word that reverses the meaning
    of my statement and then argue against the resulting distortion.

    If you disagree with my statement, QUOTE IT CORRECTLY AND STATE YOUR
    OBJECTION SEPARATELY.

    Now, to the mathematics.

    You finally quote the correct definition:

    "A Turing machine M decides a language L
    if and only if, for every input w, M halts,
    accepting if w belongs to L and rejecting otherwise."

    EXACTLY.

    Notice what that definition DOES NOT SAY.

    It does not say that M must simulate the computation described by w.

    It does not say that M must reproduce its execution trace.

    It does not say that M must use any particular kind of analysis.

    It specifies TOTALITY AND CORRECTNESS.

    NOT AN IMPLEMENTATION STRATEGY.

    Then you add:

    "All halt deciders must inherently apply finite
    string transformations that are relevant to
    the behavior specified by their input finite string."

    Fine. Let's grant that.

    SO WHAT?

    A mathematical proof that a loop terminates is relevant to its behavior.

    A ranking function is relevant to its behavior.

    A static analysis of its control-flow graph is relevant to its behavior.

    NONE OF THESE REQUIRES EXECUTING THE LOOP TO COMPLETION.

    Consider:

    int f(unsigned n) {
    while (n > 0)
    --n;
    return 0;
    }

    We can establish termination for every input by observing that n is a nonnegative integer that strictly decreases whenever the loop executes.

    We do not need to simulate every iteration.

    Your phrase "relevant to the behavior" does not establish your much
    stronger claim that a halting decider MUST simulate its input according to
    its operational semantics.

    YOU HAVE NOT PROVED THAT IMPLICATION.

    And even if you did impose such a restriction, you would merely define a restricted class of deciders.

    You would NOT refute the Halting Theorem, which concerns ALL total
    computable procedures capable of deciding the halting property.

    Finally, you write:

    "Any result that cannot be derived this way
    is outside the scope of Turing computable functions."

    Yes. And if a universal halting decider existed in your string
    transformation model, its algorithm could be translated into a Turing
    machine.

    The diagonal contradiction would apply unchanged.

    YOUR CHANGE OF FORMALISM DOES NOT CHANGE COMPUTABILITY.

    So here is the question you keep avoiding:

    **WHAT EXACTLY PREVENTS THE DIAGONAL ARGUMENT FROM APPLYING TO YOUR
    PROPOSED DECIDER?**

    Not a slogan.

    Not a repetition.

    Not another definition you invented.

    A MATHEMATICAL ARGUMENT.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 10:25:22 2026
    From Newsgroup: comp.ai.philosophy

    On 11/14/2026 8:49 AM, Python wrote:
    Le 14/11/2026 |a 15:36, olcott a |-crit :
    On 11/14/2026 4:53 AM, Python wrote:
    Le 14/11/2026 |a 02:10, olcott a |-crit :
    On 11/13/2026 7:01 PM, Python wrote:
    Le 14/11/2026 |a 01:40, olcott a |-crit :
    On 11/13/2026 6:28 PM, Python wrote:
    Le 14/11/2026 |a 01:18, olcott a |-crit :
    On 11/13/2026 6:04 PM, Python wrote:
    Le 14/11/2026 |a 00:49, olcott a |-crit :
    On 11/13/2026 5:20 PM, Python wrote:
    Peter,

    -a-a-a "Not with TMs."

    BULLSHIT.

    On 11/13/2026 5:15 PM, olcott wrote:
    On 11/13/2026 4:13 PM, Python wrote:
    Peter,

    -a-a-a-a "H only applies finite string transformations >>>>>>>>>> -a>>-a-a-a-a-a to its actual static finite string inputs." >>>>>>>>>> -a>>
    YES. WE KNOW.

    THAT IS HOW COMPUTABLE ALGORITHMS WORK.


    Not with TMs. With TMs there are a large number
    of distracting implementation specific details.


    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    With TMs there are a large number of distracting
    implementation specific details.

    No, there are not.

    So you never heard of move tape_head left?

    When we look at the whole undivided category
    of applying finite string transformations to
    finite string inputs, this is the whole kit
    and caboodle of computation.

    No tape_head moves, no read tape element write
    tape element. When we get rid of these
    implementation details thenn (then and only then)
    can we focus on what categories of finite string
    transformations are inherently required for
    each type of decider.

    We examine every detail of the whole process
    to see what is really going on.

    Peter,

    -a-a-a "So you never heard of move tape_head left?"

    FOR FUCK'S SAKE.

    Yes, Peter. A Turing machine has a tape head.

    A C program has variables.

    A lambda calculus expression has beta-reductions.

    A string rewriting system has rewriting rules.

    CONGRATULATIONS.

    YOU HAVE DISCOVERED THAT DIFFERENT MODELS OF COMPUTATION HAVE
    DIFFERENT PRIMITIVES.

    That is precisely why we study their computational equivalence.

    -a-a-a "When we get rid of these implementation details
    -a-a-a-a thenn (then and only then) can we focus..."

    NO.

    Removing the tape head does not magically reveal new laws of
    computability.

    It merely replaces one Turing-complete formalism with another.

    And any universal halting decider in your favorite string
    rewriting formalism would yield one for Turing machines.

    WHICH DIAGONALIZATION RULES OUT.

    After 22 years, you are still mistaking a change of notation for >>>>>>> a mathematical breakthrough.


    When we look at this through the simplest most
    generic abstraction of finite string transformations
    to INPUT finite strings thenn (then and only then)

    we can begin to look deeper into what categories
    of finite string transformations are specifically
    relevant to specific decision criteria.

    strcmp() must compare strings
    halt deciders must examine behavior

    Peter,

    -a-a-a "strcmp() must compare strings
    -a-a-a-a halt deciders must examine behavior"

    FOR FUCK'S SAKE.

    A halting decider must DETERMINE WHETHER A PROGRAM HALTS.

    That is its specification.

    HOW it determines the answer is an [MANDATORY] implementation detail. >>>>>

    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.
    To fully understand what the Hell is actually going on.

    Peter,

    YOU HAVE JUST FALSIFIED MY WORDS.

    I wrote:

    -a-a-a "HOW it determines the answer is an
    -a-a-a-a implementation detail."

    You quoted me as writing:

    -a-a-a "HOW it determines the answer is an
    -a-a-a-a [MANDATORY] implementation detail."

    I DID NOT WRITE "[MANDATORY]".

    YOU INSERTED IT.

    And that insertion changes the meaning of my statement.


    Yes and I used standard syntax to indicate that it was inserted.

    You also deleted virtually my entire argument, including the
    questions you have repeatedly refused to answer.

    Trimming quotations is normal.

    ALTERING SOMEONE ELSE'S WORDS TO MAKE THEM SAY SOMETHING DIFFERENT IS
    NOT.

    And then you repeat:

    -a-a-a "To fully understand what the Hell is
    -a-a-a-a actually going on."

    FIVE TIMES.


    You seem to have a great difficulty paying close attention.
    Richard says that he has ADD and the repetition did help
    him focus.

    Well, Peter, here's something you should understand:

    YOU DO NOT GET TO REWRITE MY ARGUMENT AND THEN PRETEND I MADE YOURS.

    You have repeatedly accused others of dishonesty.

    NOW LOOK AT WHAT YOU JUST DID.


    I used standard syntax to indicate that [MANDATORY] was inserted.
    I used standard syntax to indicate that [MANDATORY] was inserted.
    I used standard syntax to indicate that [MANDATORY] was inserted.
    I used standard syntax to indicate that [MANDATORY] was inserted.

    In order to deeply understand what the Hell is going
    on implementation details must be addressed at some
    level of abstraction.

    By applying finite string transformation rules to finite
    string inputs to derive any and all outputs.
    We see two things:

    (1) Any result that cannot be derived this way is outside
    the scope of Turing commutable functions the same way that
    filling your tires with air is outside the scope of your
    toaster.

    (2) Within this simplest Turing equivalent model of
    computation we can examine the notion of deciders more
    deeply.

    the set of all finite strings over +u, including the empty
    string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u*
    if and only if, for every input w ree +u*, M halts, accepting
    if w ree L and rejecting if w ree L.

    All non-trivial deciders must inherently apply finite string
    transformations that are relevant to their decision criteria.

    All halt deciders must inherently apply finite string
    transformations that are relevant to the behavior specified
    by their input finite string.

    Peter,

    -a-a "I used standard syntax to indicate that
    -a-a-a [MANDATORY] was inserted."

    Yes, the brackets indicate an editorial insertion.

    They do NOT give you permission to insert a word that reverses the
    meaning of my statement and then argue against the resulting distortion.

    If you disagree with my statement, QUOTE IT CORRECTLY AND STATE YOUR OBJECTION SEPARATELY.

    Now, to the mathematics.

    You finally quote the correct definition:

    -a-a "A Turing machine M decides a language L
    -a-a-a if and only if, for every input w, M halts,
    -a-a-a accepting if w belongs to L and rejecting otherwise."

    EXACTLY.

    Notice what that definition DOES NOT SAY.

    It does not say that M must simulate the computation described by w.

    It does not say that M must reproduce its execution trace.

    It does not say that M must use any particular kind of analysis.

    It specifies TOTALITY AND CORRECTNESS.

    NOT AN IMPLEMENTATION STRATEGY.

    Then you add:

    -a-a "All halt deciders must inherently apply finite
    -a-a-a string transformations that are relevant to
    -a-a-a the behavior specified by their input finite string."

    Fine. Let's grant that.


    Great we finally made two steps of progress towards
    mutual agreement. That is the key way that you are
    better than any other reviewer.

    SO WHAT?

    A mathematical proof that a loop terminates is relevant to its behavior.

    A ranking function is relevant to its behavior.


    Not sure what this is, yet seems plausible to me.

    A static analysis of its control-flow graph is relevant to its behavior.

    NONE OF THESE REQUIRES EXECUTING THE LOOP TO COMPLETION.


    I will grant you that.

    Consider:

    -a-a int f(unsigned n) {
    -a-a-a-a-a-a while (n > 0)
    -a-a-a-a-a-a-a-a-a-a --n;
    -a-a-a-a-a-a return 0;
    -a-a }

    We can establish termination for every input by observing that n is a nonnegative integer that strictly decreases whenever the loop executes.

    We do not need to simulate every iteration.


    Yes I will grant you that. These are all simply
    short cuts to reduce the time that it takes to
    perform an actual simulation.

    It still remains the case that these short-cuts
    must remain consistent with what the behavior of
    the simulation would be up to the point where
    halting can be determined.

    Most crucially only the finite string input can
    be sued for this basis.

    Your phrase "relevant to the behavior" does not establish your much
    stronger claim that a halting decider MUST simulate its input according
    to its operational semantics.

    YOU HAVE NOT PROVED THAT IMPLICATION.


    That the behavior specified by the input only includes
    the measurement of this behavior by the decider is
    established by the finite string transformations
    applied to finite string inputs model of computation.

    And even if you did impose such a restriction, you would merely define a restricted class of deciders.


    Yes is is restricted to computations that actually
    make decisions and thus rule out lucky guesses.

    You would NOT refute the Halting Theorem, which concerns ALL total computable procedures capable of deciding the halting property.

    Finally, you write:

    -a-a "Any result that cannot be derived this way
    -a-a-a is outside the scope of Turing computable functions."

    Yes. And if a universal halting decider existed in your string transformation model, its algorithm could be translated into a Turing machine.


    Thus outside the scope of Turing computable functions in
    the same way that filling your tires with air is outside
    the scope of your toaster.

    This is a type mismatch error than an assessment that
    some decision problems are too difficult for computation.

    The diagonal contradiction would apply unchanged.

    YOUR CHANGE OF FORMALISM DOES NOT CHANGE COMPUTABILITY.

    So here is the question you keep avoiding:

    **WHAT EXACTLY PREVENTS THE DIAGONAL ARGUMENT FROM APPLYING TO YOUR
    PROPOSED DECIDER?**


    Type mismatch error.

    Not a slogan.

    Not a repetition.

    Not another definition you invented.

    A MATHEMATICAL ARGUMENT.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 17:02:27 2026
    From Newsgroup: comp.ai.philosophy

    Peter,

    We have finally made some progress.

    You explicitly concede:

    "I will grant you that."

    And:

    "Yes I will grant you that."

    In particular, you now acknowledge that static analysis can establish termination WITHOUT executing every step of the program.

    GOOD.

    But then you write:

    "These are all simply short cuts to reduce the
    time that it takes to perform an actual simulation."

    NO.

    A mathematical proof of termination is not necessarily an abbreviated simulation.

    It can establish a property of ALL possible executions without
    reconstructing ANY complete execution trace.

    You are confusing reasoning ABOUT a computation with PERFORMING that computation.

    "These short-cuts must remain consistent with
    what the behavior of the simulation would be"

    OF COURSE.

    That is called CORRECTNESS.

    It does not imply that the analysis must simulate the program.

    Now to your latest escape hatch:

    "Type mismatch error."

    WHAT TYPE MISMATCH?

    The halting problem concerns encoded programs and their inputs.

    A hypothetical universal decider H accepts such encodings and returns a Boolean answer.

    The diagonal program D is itself a valid program.

    Its encoding is a valid input to H.

    And D calls H on that encoding.

    THERE IS NO TYPE MISMATCH.

    Here is the argument, stripped of every irrelevant implementation detail.

    Assume H is total and correct.

    Define D(x) as follows:

    if H(x, x) says "halts":
    loop forever
    else:
    halt

    Now consider D(D).

    If H(D, D) says "halts", D(D) does not halt.

    If H(D, D) says "does not halt", D(D) halts.

    CONTRADICTION.

    If H refuses D as an invalid input, then H is not a universal decider over
    the specified domain of valid program encodings.

    If H fails to return, then H is not total.

    If H returns an incorrect answer, then H is not correct.

    WHICH ONE IS YOUR "TYPE MISMATCH"?

    And notice something else.

    The contradiction does not arise because D is incoherent.

    It arises because the assumption that H is total and correct is
    impossible.

    That is exactly what the Halting Theorem proves.

    You have spent years insisting that the diagonal program cannot reach its return statement when simulated by your particular H.

    But the proof assumes a HYPOTHETICAL TOTAL H.

    Under that assumption, its call MUST return.

    If your implementation cannot make that call return, you have demonstrated that YOUR IMPLEMENTATION IS NOT TOTAL.

    NOT THAT TURING WAS WRONG.

    So, Peter, enough analogies about toasters and tires.

    IDENTIFY THE TYPE.

    IDENTIFY THE EXPECTED TYPE.

    IDENTIFY THE ACTUAL TYPE.

    AND SHOW THE MISMATCH.

    Otherwise, "type mismatch" is just another slogan replacing the
    mathematical argument you have never supplied.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 08:55:01 2026
    From Newsgroup: comp.ai.philosophy

    On 11/14/26 4:52 AM, olcott wrote:
    On 11/14/2026 12:55 AM, dart200 wrote:
    On 11/13/26 9:02 PM, olcott wrote:
    On 11/13/2026 10:19 PM, dart200 wrote:
    On 11/13/26 5:02 PM, olcott wrote:
    On 11/13/2026 6:50 PM, dart200 wrote:
    On 11/13/26 4:48 PM, olcott wrote:
    On 11/13/2026 6:37 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:23, olcott wrote:
    On 11/13/2026 6:16 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 17:03, olcott wrote:
    On 11/13/2026 5:57 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 16:20, olcott wrote:
    On 11/13/2026 4:51 PM, Andr|- G. Isaak wrote:
    On 2026-11-13 14:31, olcott wrote:

    HHH(DD)==0
    (I need to simplify my repository and go back to D/H) >>>>>>>>>>>>>>> Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH. >>>>>>>>>>>>>>
    Either DD halts or it doesn't. It doesn't halt "relative" >>>>>>>>>>>>>> to something.

    Andr|-


    In every case a halt decider is at most the
    proxy for the behavior of a computation.

    That's just errant nonsense. A halt decider, were such >>>>>>>>>>>> things to exist, answers a question about a specific
    computation. There are no 'proxies' involved


    Let +u be a finite, nonempty alphabet, let +u* denote
    the set of all finite strings over +u, including the empty >>>>>>>>>>> string +|, and let L rea +u* be a language

    Decider. A Turing machine M decides a language L rea +u* >>>>>>>>>>> if and only if, for every input w ree +u*, M halts, accepting >>>>>>>>>>

    I have absolutely no idea why you think giving a definition of >>>>>>>>>> a decider somehow addresses any of my points.


    +u* has zero machines thus no possible way to directly examine >>>>>>>>> machine behavior. We can at best indirectly examine machine >>>>>>>>> behavior through finite string proxies that encode sequences of >>>>>>>>> steps.

    You are seriously confused. whether +u* mentions strings,
    machines, integers, etc. is entirely irrelevant.

    That computation only operates on strings and never
    operates on machines proves that no halt decision
    on any input is more than a proxy for the behavior
    of any machine.

    ... the halt decision is in respect to the behavior of the machine >>>>>> defined by the string ...


    That has ALWAYS been counter-factual
    and can only be seen as counter-factual
    when one pays enormously more attention
    to the actual details than anyone has
    ever paid before.


    lol, polcott what does "counter-factual" mean to you?


    PROVEN FALSE ON THE BASIS OF ITS MEANING.

    that's not what a counter-factual is:


    I am stipulating that it what I mean.
    3 > 5 is counter-factual.

    that's not what a counter-factual is, that's just a false expression

    a counter-factual is a hypothetical implication based on a false premise

    "if P => Q" is a counter-factual statement iff P is counter to
    historical facts


    a counter-factual is a hypothetical implication based on a false premise

    The behavior of x(y) is specified by the
    input to H(x,y) ONLY when x does not call H(x,y).


    ironically HHH(DD)->0 is based on the counter-factual reasoning that
    if HHH had let DD run, then it would be non-terminating


    Halt deciders are only accountable for determining
    the behavior that their input finite string specifies.

    DD specifies a halting machine

    this is counterfactual because clearly HHH does not let DD run
    forever, it cuts off the simulation of DD in order to return 0


    The same way that it would for an infinite loop, stupid.


    i'm not sure if i really consider tracing the execution of a machine the
    same as simulating it
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 21:38:33 2026
    From Newsgroup: comp.ai.philosophy

    On 11/14/2026 11:02 AM, Python wrote:
    Peter,

    We have finally made some progress.

    You explicitly concede:

    -a-a "I will grant you that."

    And:

    -a-a "Yes I will grant you that."

    In particular, you now acknowledge that static analysis can establish termination WITHOUT executing every step of the program.

    GOOD.


    I knew that.

    But then you write:

    -a-a "These are all simply short cuts to reduce the
    -a-a-a time that it takes to perform an actual simulation."

    NO.


    It is only behavior that is consistent with the behavior
    of input I simulated by H that measures the behavior of
    I AS AN INPUT TO H.

    A mathematical proof of termination is not necessarily an abbreviated simulation.

    It can establish a property of ALL possible executions without reconstructing ANY complete execution trace.


    An input that takes no arguments eliminates the
    Frederick Brooks (No Silver Bullet Essence and
    Accidents of Software Engineering) inessential
    complexity of an input with arguments.

    You are confusing reasoning ABOUT a computation with PERFORMING that computation.

    -a-a "These short-cuts must remain consistent with
    -a-a-a what the behavior of the simulation would be"

    OF COURSE.

    That is called CORRECTNESS.


    Great we are back to mutual agreement.
    DD simulated by HHH provides the ultimate basis of
    the behavior that DD (AS AN INPUT) specifies to HHH.

    Deciders apply finite string transformation /
    inference steps to finite string inputs according
    to a decision criteria.

    It does not imply that the analysis must simulate the program.

    Now to your latest escape hatch:

    -a-a "Type mismatch error."

    WHAT TYPE MISMATCH?

    The halting problem concerns encoded programs and their inputs.

    A hypothetical universal decider H accepts such encodings and returns a Boolean answer.

    The diagonal program D is itself a valid program.

    Its encoding is a valid input to H.

    And D calls H on that encoding.

    THERE IS NO TYPE MISMATCH.


    The type mismatch is the expectation that HHH
    reports on the behavior of the executable
    process DD() instead of the behavior that the
    finite string (AS AN INPUT) specifies to HHH.

    Here is the argument, stripped of every irrelevant implementation detail.

    Assume H is total and correct.

    Define D(x) as follows:

    -a-a if H(x, x) says "halts":
    -a-a-a-a-a-a loop forever
    -a-a else:
    -a-a-a-a-a-a halt

    Now consider D(D).

    If H(D, D) says "halts", D(D) does not halt.

    If H(D, D) says "does not halt", D(D) halts.

    CONTRADICTION.

    // eliminate inessential argument to DD

    typedef int (*ptr)();
    int HHH(ptr P);

    01 int DD()
    02 {
    03 int Halt_Status = HHH(DD);
    04 if (Halt_Status)
    05 HERE: goto HERE;
    06 return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11 HHH(DD);
    12 }

    Simulation Trace
    Line 11: main() invokes HHH(DD);

    Line 03: DD calls HHH(DD); HHH simulates DD;
    Line 03: DD calls HHH(DD); HHH simulates DD;
    Line 03: DD calls HHH(DD); HHH simulates DD;
    Line 03: DD calls HHH(DD); HHH simulates DD; ...

    <snip>
    --
    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 Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 22:58:45 2026
    From Newsgroup: comp.ai.philosophy

    On 11/13/2026 5:21 PM, Andr|- G. Isaak wrote:
    [...]

    Have you ever messed around with L-systems? So fun.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 23:01:12 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 1:54 PM, Python wrote:
    [...]

    PO better not abort a possible infinte sequence. The server is up
    reaping data. It might run for as long as it can, infinite. But PO cuts
    it off, Oh my!
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 23:02:34 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 1:55 PM, dart200 wrote:
    On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
    On 11/12/2026 12:40 PM, dart200 wrote:
    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast the
    shit out of a threads stack... I made a manual recursion for
    AppleSoft BASIC for fun while trying to port some of my algos to it:

    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-

    [...]

    Well, basically to see how portable my algos really are. So far, I
    have all of my fractals that use recursion, and even some of my n-ary
    vector fields! Let me get an older screenshot of it, I posted it in a
    BASIC group over on the FB... Found it:

    https://i.ibb.co/My8QQRdm/image.png

    Can you see it?

    https://i.ibb.co/My8QQRdm/image.png

    wow pretty nuts ...

    but not as crazy as porting them to the typescript static type checker!

    https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-checker- heres-how-types-execute-code-50i1

    maybe u can do that one next


    Well, AppleSoft BASIC is pretty old. If it can go there, which it can,
    well, ahhh. That is good enough for me. I started programming with BASIC.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 23:13:33 2026
    From Newsgroup: comp.ai.philosophy

    On 11/14/2026 6:49 AM, Python wrote:
    [...]

    Afaict, PO is a person that might be able to trick the idiots out there.
    Likes kiddy porn, etc...
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 23:16:25 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 6:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or
    simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive operations
    that compare strings

    We can compare strings in pure C, so std lib whatever.



    (The standard libraries do; the language does not).
    So exactly which operations is it supposed to use? And if you claim that strcmp() is restricted to rely on strcmp() then you're caught in an infinitely recursive trap.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no restrictions
    on which sorts of operations a halt decider can make use of, provided it ultimately returns the correct answer.

    Andr|-


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sat Nov 14 23:17:12 2026
    From Newsgroup: comp.ai.philosophy

    On 11/14/2026 11:16 PM, Chris M. Thomasson wrote:
    On 11/12/2026 6:59 PM, Andr|- G. Isaak wrote:
    On 2026-11-12 17:48, olcott wrote:
    On 11/12/2026 6:32 PM, Python wrote:
    Peter,

    -a-a-a "when H applies the most relevant finite string
    -a-a-a-a transformation / inference steps to its static
    -a-a-a-a finite string D, then this input D cannot reach
    -a-a-a-a that code."

    YOU ARE STILL MISSING THE POINT.

    The Halting Theorem does not assume that H works by executing or
    simulating D.


    strcmp() is limited to those operations that
    compare strings.

    That's unfortunate, since C doesn't contain *any* primitive operations
    that compare strings

    We can compare strings in pure C, so std lib whatever.

    NO std lib whatsoever. Damn typos! Sorry. ;^o




    (The standard libraries do; the language does not). So exactly which
    operations is it supposed to use? And if you claim that strcmp() is
    restricted to rely on strcmp() then you're caught in an infinitely
    recursive trap.

    Halt deciders are limited to those operations
    that can see behavior.

    Operations can't "see" behaviour. And there's absolutely no
    restrictions on which sorts of operations a halt decider can make use
    of, provided it ultimately returns the correct answer.

    Andr|-



    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 00:33:14 2026
    From Newsgroup: comp.ai.philosophy

    On 11/14/26 11:02 PM, Chris M. Thomasson wrote:
    On 11/12/2026 1:55 PM, dart200 wrote:
    On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
    On 11/12/2026 12:40 PM, dart200 wrote:
    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>

    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>> invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based >>>>>> on the invariant that HHH not cut DD simulation's short after the >>>>>> initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast the
    shit out of a threads stack... I made a manual recursion for
    AppleSoft BASIC for fun while trying to port some of my algos to it:

    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-

    [...]

    Well, basically to see how portable my algos really are. So far, I
    have all of my fractals that use recursion, and even some of my n-ary
    vector fields! Let me get an older screenshot of it, I posted it in a
    BASIC group over on the FB... Found it:

    https://i.ibb.co/My8QQRdm/image.png

    Can you see it?

    https://i.ibb.co/My8QQRdm/image.png

    wow pretty nuts ...

    but not as crazy as porting them to the typescript static type checker!

    https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-checker-
    heres-how-types-execute-code-50i1

    maybe u can do that one next


    Well, AppleSoft BASIC is pretty old. If it can go there, which it can,
    well, ahhh. That is good enough for me. I started programming with BASIC.

    all turing complete languages are convertible to each other, provably so

    we don't know any way of describing an executable algorithm that is more powerful in computability than a turing complete language, that therefor
    can be run on a turing machine

    i'm not sure polcott will ever understand this point to be frank
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 00:38:23 2026
    From Newsgroup: comp.ai.philosophy

    On 11/15/2026 12:33 AM, dart200 wrote:
    On 11/14/26 11:02 PM, Chris M. Thomasson wrote:
    On 11/12/2026 1:55 PM, dart200 wrote:
    On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
    On 11/12/2026 12:40 PM, dart200 wrote:
    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions >>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>>> invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical
    based on the invariant that HHH not cut DD simulation's short
    after the initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast the >>>>>> shit out of a threads stack... I made a manual recursion for
    AppleSoft BASIC for fun while trying to port some of my algos to it: >>>>>
    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-

    [...]

    Well, basically to see how portable my algos really are. So far, I
    have all of my fractals that use recursion, and even some of my n-
    ary vector fields! Let me get an older screenshot of it, I posted it
    in a BASIC group over on the FB... Found it:

    https://i.ibb.co/My8QQRdm/image.png

    Can you see it?

    https://i.ibb.co/My8QQRdm/image.png

    wow pretty nuts ...

    but not as crazy as porting them to the typescript static type checker!

    https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-
    checker- heres-how-types-execute-code-50i1

    maybe u can do that one next


    Well, AppleSoft BASIC is pretty old. If it can go there, which it can,
    well, ahhh. That is good enough for me. I started programming with BASIC.

    all turing complete languages are convertible to each other, provably so

    we don't know any way of describing an executable algorithm that is more powerful in computability than a turing complete language, that therefor
    can be run on a turing machine

    i'm not sure polcott will ever understand this point to be frank


    Yeah. So I can port it and gain the data. But I also want to plot that data. --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 00:40:31 2026
    From Newsgroup: comp.ai.philosophy

    On 11/15/2026 12:38 AM, Chris M. Thomasson wrote:
    On 11/15/2026 12:33 AM, dart200 wrote:
    On 11/14/26 11:02 PM, Chris M. Thomasson wrote:
    On 11/12/2026 1:55 PM, dart200 wrote:
    On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
    On 11/12/2026 12:40 PM, dart200 wrote:
    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>>>> invariant that HHH not cut DD simulation's short after the >>>>>>>>>> recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical
    based on the invariant that HHH not cut DD simulation's short >>>>>>>> after the initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast
    the shit out of a threads stack... I made a manual recursion for >>>>>>> AppleSoft BASIC for fun while trying to port some of my algos to it: >>>>>>
    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-

    [...]

    Well, basically to see how portable my algos really are. So far, I
    have all of my fractals that use recursion, and even some of my n-
    ary vector fields! Let me get an older screenshot of it, I posted
    it in a BASIC group over on the FB... Found it:

    https://i.ibb.co/My8QQRdm/image.png

    Can you see it?

    https://i.ibb.co/My8QQRdm/image.png

    wow pretty nuts ...

    but not as crazy as porting them to the typescript static type checker! >>>>
    https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-
    checker- heres-how-types-execute-code-50i1

    maybe u can do that one next


    Well, AppleSoft BASIC is pretty old. If it can go there, which it
    can, well, ahhh. That is good enough for me. I started programming
    with BASIC.

    all turing complete languages are convertible to each other, provably so

    we don't know any way of describing an executable algorithm that is
    more powerful in computability than a turing complete language, that
    therefor can be run on a turing machine

    i'm not sure polcott will ever understand this point to be frank


    Yeah. So I can port it and gain the data. But I also want to plot that
    data.

    I use a shit load of floating point...
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 00:42:15 2026
    From Newsgroup: comp.ai.philosophy

    On 11/12/2026 1:55 PM, dart200 wrote:
    On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
    On 11/12/2026 12:40 PM, dart200 wrote:
    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast the
    shit out of a threads stack... I made a manual recursion for
    AppleSoft BASIC for fun while trying to port some of my algos to it:

    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-

    [...]

    Well, basically to see how portable my algos really are. So far, I
    have all of my fractals that use recursion, and even some of my n-ary
    vector fields! Let me get an older screenshot of it, I posted it in a
    BASIC group over on the FB... Found it:

    https://i.ibb.co/My8QQRdm/image.png

    Can you see it?

    https://i.ibb.co/My8QQRdm/image.png

    wow pretty nuts ...

    but not as crazy as porting them to the typescript static type checker!

    https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-checker- heres-how-types-execute-code-50i1

    maybe u can do that one next


    https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-checker-heres-how-types-execute-code-50i1

    Pretty interesting! Thanks.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 01:20:28 2026
    From Newsgroup: comp.ai.philosophy

    On 11/15/26 12:38 AM, Chris M. Thomasson wrote:
    On 11/15/2026 12:33 AM, dart200 wrote:
    On 11/14/26 11:02 PM, Chris M. Thomasson wrote:
    On 11/12/2026 1:55 PM, dart200 wrote:
    On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
    On 11/12/2026 12:40 PM, dart200 wrote:
    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>>>> invariant that HHH not cut DD simulation's short after the >>>>>>>>>> recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical
    based on the invariant that HHH not cut DD simulation's short >>>>>>>> after the initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast
    the shit out of a threads stack... I made a manual recursion for >>>>>>> AppleSoft BASIC for fun while trying to port some of my algos to it: >>>>>>
    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-

    [...]

    Well, basically to see how portable my algos really are. So far, I
    have all of my fractals that use recursion, and even some of my n-
    ary vector fields! Let me get an older screenshot of it, I posted
    it in a BASIC group over on the FB... Found it:

    https://i.ibb.co/My8QQRdm/image.png

    Can you see it?

    https://i.ibb.co/My8QQRdm/image.png

    wow pretty nuts ...

    but not as crazy as porting them to the typescript static type checker! >>>>
    https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-
    checker- heres-how-types-execute-code-50i1

    maybe u can do that one next


    Well, AppleSoft BASIC is pretty old. If it can go there, which it
    can, well, ahhh. That is good enough for me. I started programming
    with BASIC.

    all turing complete languages are convertible to each other, provably so

    we don't know any way of describing an executable algorithm that is
    more powerful in computability than a turing complete language, that
    therefor can be run on a turing machine

    i'm not sure polcott will ever understand this point to be frank


    Yeah. So I can port it and gain the data. But I also want to plot that
    data.

    what data are you gaining and/or plotting from such an exercise?
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 11:37:10 2026
    From Newsgroup: comp.ai.philosophy

    Le 15/11/2026 |a 04:38, olcott a |-crit :
    On 11/14/2026 11:02 AM, Python wrote:
    Peter,

    We have finally made some progress.

    You explicitly concede:

    -a-a "I will grant you that."

    And:

    -a-a "Yes I will grant you that."

    In particular, you now acknowledge that static analysis can establish
    termination WITHOUT executing every step of the program.

    GOOD.


    I knew that.

    But then you write:

    -a-a "These are all simply short cuts to reduce the
    -a-a-a time that it takes to perform an actual simulation."

    NO.


    It is only behavior that is consistent with the behavior
    of input I simulated by H that measures the behavior of
    I AS AN INPUT TO H.

    A mathematical proof of termination is not necessarily an abbreviated
    simulation.

    It can establish a property of ALL possible executions without
    reconstructing ANY complete execution trace.


    An input that takes no arguments eliminates the
    Frederick Brooks (No Silver Bullet Essence and
    Accidents of Software Engineering) inessential
    complexity of an input with arguments.

    You are confusing reasoning ABOUT a computation with PERFORMING that
    computation.

    -a-a "These short-cuts must remain consistent with
    -a-a-a what the behavior of the simulation would be"

    OF COURSE.

    That is called CORRECTNESS.


    Great we are back to mutual agreement.
    DD simulated by HHH provides the ultimate basis of
    the behavior that DD (AS AN INPUT) specifies to HHH.

    Deciders apply finite string transformation /
    inference steps to finite string inputs according
    to a decision criteria.

    It does not imply that the analysis must simulate the program.

    Now to your latest escape hatch:

    -a-a "Type mismatch error."

    WHAT TYPE MISMATCH?

    The halting problem concerns encoded programs and their inputs.

    A hypothetical universal decider H accepts such encodings and returns a
    Boolean answer.

    The diagonal program D is itself a valid program.

    Its encoding is a valid input to H.

    And D calls H on that encoding.

    THERE IS NO TYPE MISMATCH.


    The type mismatch is the expectation that HHH
    reports on the behavior of the executable
    process DD() instead of the behavior that the
    finite string (AS AN INPUT) specifies to HHH.

    Here is the argument, stripped of every irrelevant implementation detail.

    Assume H is total and correct.

    Define D(x) as follows:

    -a-a if H(x, x) says "halts":
    -a-a-a-a-a-a loop forever
    -a-a else:
    -a-a-a-a-a-a halt

    Now consider D(D).

    If H(D, D) says "halts", D(D) does not halt.

    If H(D, D) says "does not halt", D(D) halts.

    CONTRADICTION.

    // eliminate inessential argument to DD

    typedef int (*ptr)();
    int HHH(ptr P);

    01 int DD()
    02 {
    03 int Halt_Status = HHH(DD);
    04 if (Halt_Status)
    05 HERE: goto HERE;
    06 return Halt_Status;
    07 }
    08
    09 void main()
    10 {
    11 HHH(DD);
    12 }

    Simulation Trace
    Line 11: main() invokes HHH(DD);

    Line 03: DD calls HHH(DD); HHH simulates DD;
    Line 03: DD calls HHH(DD); HHH simulates DD;
    Line 03: DD calls HHH(DD); HHH simulates DD;
    Line 03: DD calls HHH(DD); HHH simulates DD; ...

    <snip>

    Peter,

    "The type mismatch is the expectation that HHH
    reports on the behavior of the executable
    process DD() instead of the behavior that the
    finite string (AS AN INPUT) specifies to HHH."

    THERE IS NO TYPE MISMATCH.

    A program's encoding is a finite string.

    That string describes a program.

    The program has an operational semantics.

    And the halting problem asks whether the computation described by that encoding terminates.

    THAT IS THE ENTIRE POINT OF ENCODING PROGRAMS.

    You are inventing a distinction between the behavior of a program and the behavior specified by its encoding.

    Those are not two different decision problems.

    Now consider your simulation trace:

    main() calls HHH(DD)
    DD calls HHH(DD)
    DD calls HHH(DD)
    DD calls HHH(DD)
    ...

    YES, PETER.

    YOUR HHH GETS STUCK IN INFINITE RECURSION.

    CONGRATULATIONS.

    YOU HAVE DEMONSTRATED THAT YOUR HHH IS NOT A TOTAL HALTING DECIDER.

    That is perfectly consistent with the Halting Theorem.

    In fact, it is exactly the kind of failure the theorem tells us is
    unavoidable for any proposed universal decider.

    But the diagonal proof does not assume that H works by recursively
    simulating its input.

    IT ASSUMES THAT H IS TOTAL AND CORRECT.

    Under that hypothesis, H(DD) returns an answer.

    Therefore DD reaches its conditional branch.

    And whichever answer H returns, DD does the opposite.

    THAT IS THE CONTRADICTION.

    You cannot refute a proof about ALL possible computable deciders by
    exhibiting ONE PARTICULAR DECIDER THAT FAILS.

    And your attempt to make the simulator's behavior the "ultimate basis" of
    the program's semantics is circular.

    A simulator is supposed to reproduce the semantics of the program.

    THE SEMANTICS IS NOT DEFINED BY WHETHER YOUR SIMULATOR SUCCEEDS.

    If your simulator gets stuck, that tells us something about your
    simulator.

    It does not establish that the program is invalid.

    Nor does it establish that a hypothetical total H could avoid the diagonal contradiction.

    Your entire argument amounts to:

    "My implementation of H cannot decide D."

    YES.

    THAT IS WHAT THE HALTING THEOREM PREDICTS.

    You have spent 28 years demonstrating an example of the theorem you claim
    to have refuted.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 08:11:08 2026
    From Newsgroup: comp.ai.philosophy

    On 11/15/2026 5:37 AM, Python wrote:
    Le 15/11/2026 |a 04:38, olcott a |-crit :
    On 11/14/2026 11:02 AM, Python wrote:
    Peter,

    We have finally made some progress.

    You explicitly concede:

    -a-a-a "I will grant you that."

    And:

    -a-a-a "Yes I will grant you that."

    In particular, you now acknowledge that static analysis can establish
    termination WITHOUT executing every step of the program.

    GOOD.


    I knew that.

    But then you write:

    -a-a-a "These are all simply short cuts to reduce the
    -a-a-a-a time that it takes to perform an actual simulation."

    NO.


    It is only behavior that is consistent with the behavior
    of input I simulated by H that measures the behavior of
    I AS AN INPUT TO H.

    A mathematical proof of termination is not necessarily an abbreviated
    simulation.

    It can establish a property of ALL possible executions without
    reconstructing ANY complete execution trace.


    An input that takes no arguments eliminates the
    Frederick Brooks (No Silver Bullet Essence and
    Accidents of Software Engineering) inessential
    complexity of an input with arguments.

    You are confusing reasoning ABOUT a computation with PERFORMING that
    computation.

    -a-a-a "These short-cuts must remain consistent with
    -a-a-a-a what the behavior of the simulation would be"

    OF COURSE.

    That is called CORRECTNESS.


    Great we are back to mutual agreement.
    DD simulated by HHH provides the ultimate basis of
    the behavior that DD (AS AN INPUT) specifies to HHH.

    Deciders apply finite string transformation /
    inference steps to finite string inputs according
    to a decision criteria.

    It does not imply that the analysis must simulate the program.

    Now to your latest escape hatch:

    -a-a-a "Type mismatch error."

    WHAT TYPE MISMATCH?

    The halting problem concerns encoded programs and their inputs.

    A hypothetical universal decider H accepts such encodings and returns
    a Boolean answer.

    The diagonal program D is itself a valid program.

    Its encoding is a valid input to H.

    And D calls H on that encoding.

    THERE IS NO TYPE MISMATCH.


    The type mismatch is the expectation that HHH
    reports on the behavior of the executable
    process DD() instead of the behavior that the
    finite string (AS AN INPUT) specifies to HHH.

    Here is the argument, stripped of every irrelevant implementation
    detail.

    Assume H is total and correct.

    Define D(x) as follows:

    -a-a-a if H(x, x) says "halts":
    -a-a-a-a-a-a-a loop forever
    -a-a-a else:
    -a-a-a-a-a-a-a halt

    Now consider D(D).

    If H(D, D) says "halts", D(D) does not halt.

    If H(D, D) says "does not halt", D(D) halts.

    CONTRADICTION.

    // eliminate inessential argument to DD

    typedef int (*ptr)();
    int HHH(ptr P);

    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 }
    08
    09 void main()
    10 {
    11-a HHH(DD);
    12 }

    Simulation Trace
    Line 11: main() invokes HHH(DD);

    Line 03: DD calls HHH(DD); HHH simulates DD;
    -a Line 03: DD calls HHH(DD); HHH simulates DD;
    -a-a Line 03: DD calls HHH(DD); HHH simulates DD;
    -a-a-a Line 03: DD calls HHH(DD); HHH simulates DD; ...

    <snip>

    Peter,

    -a-a "The type mismatch is the expectation that HHH
    -a-a-a reports on the behavior of the executable
    -a-a-a process DD() instead of the behavior that the
    -a-a-a finite string (AS AN INPUT) specifies to HHH."

    THERE IS NO TYPE MISMATCH.

    A program's encoding is a finite string.

    That string describes a program.

    The program has an operational semantics.

    And the halting problem asks whether the computation described by that encoding terminates.


    It asks about the behavior of a machine that no
    halt decider has direct access to.

    The finite string encoding of the machine (as an input)
    does specify the behavior of the static finite string
    input EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER,
    otherwise it is a valid proxy for the behavior of the
    underlying machine.

    **Computation defined**
    Turing equivalent Post canonical systems and semi-Thue
    systems are simplified and made generic as follows:

    All Turing equivalent computations can be reduced to
    applying finite string transformation rules to finite
    string inputs to derive any and all outputs.

    Deciders only apply finite string transformation/inference
    steps to their finite strings AS INPUTS.

    They must only apply inference steps that are relevant
    to the decision criterion.

    Thus for halt deciders these inference steps are restricted
    to the operational semantics of the language of computation
    of the input.


    THAT IS THE ENTIRE POINT OF ENCODING PROGRAMS.

    You are inventing a distinction between the behavior of a program and
    the behavior specified by its encoding.

    Those are not two different decision problems.

    Now consider your simulation trace:

    -a-a main() calls HHH(DD)
    -a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ...

    YES, PETER.

    YOUR HHH GETS STUCK IN INFINITE RECURSION.

    CONGRATULATIONS.

    YOU HAVE DEMONSTRATED THAT YOUR HHH IS NOT A TOTAL HALTING DECIDER.


    There are at least two ways that this can be correctly understood:
    (1) The behavior that the the input finite string DD
    specifies to its halt decider HHH is non-halting behavior.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    (2) When we hypothesize that HHH is applying a Prolog unify_with_occurs_check() to its input the DD is rejected
    as bad input. I report this one because it is exactly the
    same process as unify_with_occurs_check(LP, not(true(LP))).

    That is perfectly consistent with the Halting Theorem.

    In fact, it is exactly the kind of failure the theorem tells us is unavoidable for any proposed universal decider.

    But the diagonal proof does not assume that H works by recursively simulating its input.

    IT ASSUMES THAT H IS TOTAL AND CORRECT.

    Under that hypothesis, H(DD) returns an answer.

    Therefore DD reaches its conditional branch.

    And whichever answer H returns, DD does the opposite.

    THAT IS THE CONTRADICTION.

    You cannot refute a proof about ALL possible computable deciders by exhibiting ONE PARTICULAR DECIDER THAT FAILS.

    And your attempt to make the simulator's behavior the "ultimate basis"
    of the program's semantics is circular.

    A simulator is supposed to reproduce the semantics of the program.

    THE SEMANTICS IS NOT DEFINED BY WHETHER YOUR SIMULATOR SUCCEEDS.


    The semantics is the operational semantics of C applied
    to the decision criteria as inference steps.

    If your simulator gets stuck, that tells us something about your simulator.

    It does not establish that the program is invalid.

    Nor does it establish that a hypothetical total H could avoid the
    diagonal contradiction.

    Your entire argument amounts to:

    "My implementation of H cannot decide D."

    YES.

    THAT IS WHAT THE HALTING THEOREM PREDICTS.

    You have spent 28 years demonstrating an example of the theorem you
    claim to have refuted.
    --
    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 Python@jpierre.messager@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 20:14:57 2026
    From Newsgroup: comp.ai.philosophy

    Le 15/11/2026 |a 15:11, olcott a |-crit :
    On 11/15/2026 5:37 AM, Python wrote:
    Le 15/11/2026 |a 04:38, olcott a |-crit :
    On 11/14/2026 11:02 AM, Python wrote:
    Peter,

    We have finally made some progress.

    You explicitly concede:

    -a-a-a "I will grant you that."

    And:

    -a-a-a "Yes I will grant you that."

    In particular, you now acknowledge that static analysis can establish >>>> termination WITHOUT executing every step of the program.

    GOOD.


    I knew that.

    But then you write:

    -a-a-a "These are all simply short cuts to reduce the
    -a-a-a-a time that it takes to perform an actual simulation."

    NO.


    It is only behavior that is consistent with the behavior
    of input I simulated by H that measures the behavior of
    I AS AN INPUT TO H.

    A mathematical proof of termination is not necessarily an abbreviated >>>> simulation.

    It can establish a property of ALL possible executions without
    reconstructing ANY complete execution trace.


    An input that takes no arguments eliminates the
    Frederick Brooks (No Silver Bullet Essence and
    Accidents of Software Engineering) inessential
    complexity of an input with arguments.

    You are confusing reasoning ABOUT a computation with PERFORMING that
    computation.

    -a-a-a "These short-cuts must remain consistent with
    -a-a-a-a what the behavior of the simulation would be"

    OF COURSE.

    That is called CORRECTNESS.


    Great we are back to mutual agreement.
    DD simulated by HHH provides the ultimate basis of
    the behavior that DD (AS AN INPUT) specifies to HHH.

    Deciders apply finite string transformation /
    inference steps to finite string inputs according
    to a decision criteria.

    It does not imply that the analysis must simulate the program.

    Now to your latest escape hatch:

    -a-a-a "Type mismatch error."

    WHAT TYPE MISMATCH?

    The halting problem concerns encoded programs and their inputs.

    A hypothetical universal decider H accepts such encodings and returns >>>> a Boolean answer.

    The diagonal program D is itself a valid program.

    Its encoding is a valid input to H.

    And D calls H on that encoding.

    THERE IS NO TYPE MISMATCH.


    The type mismatch is the expectation that HHH
    reports on the behavior of the executable
    process DD() instead of the behavior that the
    finite string (AS AN INPUT) specifies to HHH.

    Here is the argument, stripped of every irrelevant implementation
    detail.

    Assume H is total and correct.

    Define D(x) as follows:

    -a-a-a if H(x, x) says "halts":
    -a-a-a-a-a-a-a loop forever
    -a-a-a else:
    -a-a-a-a-a-a-a halt

    Now consider D(D).

    If H(D, D) says "halts", D(D) does not halt.

    If H(D, D) says "does not halt", D(D) halts.

    CONTRADICTION.

    // eliminate inessential argument to DD

    typedef int (*ptr)();
    int HHH(ptr P);

    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 }
    08
    09 void main()
    10 {
    11-a HHH(DD);
    12 }

    Simulation Trace
    Line 11: main() invokes HHH(DD);

    Line 03: DD calls HHH(DD); HHH simulates DD;
    -a Line 03: DD calls HHH(DD); HHH simulates DD;
    -a-a Line 03: DD calls HHH(DD); HHH simulates DD;
    -a-a-a Line 03: DD calls HHH(DD); HHH simulates DD; ...

    <snip>

    Peter,

    -a-a "The type mismatch is the expectation that HHH
    -a-a-a reports on the behavior of the executable
    -a-a-a process DD() instead of the behavior that the
    -a-a-a finite string (AS AN INPUT) specifies to HHH."

    THERE IS NO TYPE MISMATCH.

    A program's encoding is a finite string.

    That string describes a program.

    The program has an operational semantics.

    And the halting problem asks whether the computation described by that
    encoding terminates.


    It asks about the behavior of a machine that no
    halt decider has direct access to.

    The finite string encoding of the machine (as an input)
    does specify the behavior of the static finite string
    input EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER,
    otherwise it is a valid proxy for the behavior of the
    underlying machine.

    **Computation defined**
    Turing equivalent Post canonical systems and semi-Thue
    systems are simplified and made generic as follows:

    All Turing equivalent computations can be reduced to
    applying finite string transformation rules to finite
    string inputs to derive any and all outputs.

    Deciders only apply finite string transformation/inference
    steps to their finite strings AS INPUTS.

    They must only apply inference steps that are relevant
    to the decision criterion.

    Thus for halt deciders these inference steps are restricted
    to the operational semantics of the language of computation
    of the input.


    THAT IS THE ENTIRE POINT OF ENCODING PROGRAMS.

    You are inventing a distinction between the behavior of a program and
    the behavior specified by its encoding.

    Those are not two different decision problems.

    Now consider your simulation trace:

    -a-a main() calls HHH(DD)
    -a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ...

    YES, PETER.

    YOUR HHH GETS STUCK IN INFINITE RECURSION.

    CONGRATULATIONS.

    YOU HAVE DEMONSTRATED THAT YOUR HHH IS NOT A TOTAL HALTING DECIDER.


    There are at least two ways that this can be correctly understood:
    (1) The behavior that the the input finite string DD
    specifies to its halt decider HHH is non-halting behavior.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    (2) When we hypothesize that HHH is applying a Prolog unify_with_occurs_check() to its input the DD is rejected
    as bad input. I report this one because it is exactly the
    same process as unify_with_occurs_check(LP, not(true(LP))).

    That is perfectly consistent with the Halting Theorem.

    In fact, it is exactly the kind of failure the theorem tells us is
    unavoidable for any proposed universal decider.

    But the diagonal proof does not assume that H works by recursively
    simulating its input.

    IT ASSUMES THAT H IS TOTAL AND CORRECT.

    Under that hypothesis, H(DD) returns an answer.

    Therefore DD reaches its conditional branch.

    And whichever answer H returns, DD does the opposite.

    THAT IS THE CONTRADICTION.

    You cannot refute a proof about ALL possible computable deciders by
    exhibiting ONE PARTICULAR DECIDER THAT FAILS.

    And your attempt to make the simulator's behavior the "ultimate basis"
    of the program's semantics is circular.

    A simulator is supposed to reproduce the semantics of the program.

    THE SEMANTICS IS NOT DEFINED BY WHETHER YOUR SIMULATOR SUCCEEDS.


    The semantics is the operational semantics of C applied
    to the decision criteria as inference steps.

    If your simulator gets stuck, that tells us something about your simulator. >>
    It does not establish that the program is invalid.

    Nor does it establish that a hypothetical total H could avoid the
    diagonal contradiction.

    Your entire argument amounts to:

    "My implementation of H cannot decide D."

    YES.

    THAT IS WHAT THE HALTING THEOREM PREDICTS.

    You have spent 28 years demonstrating an example of the theorem you
    claim to have refuted.

    Peter,

    "The finite string encoding of the machine
    does specify the behavior [...] EXCEPT WHEN
    THE INPUT CALLS ITS OWN DECIDER"

    THERE IT IS.

    YOUR ENTIRE "REFUTATION" IN ONE SENTENCE.

    You accept that program encodings describe program behavior.

    EXCEPT WHEN DIAGONALIZATION BECOMES INCONVENIENT.

    That exception is not a theorem.

    It is something you have INVENTED to escape the contradiction.

    A program does not become invalid merely because it calls another program
    that analyzes it.

    And a hypothetical total halting decider does not acquire an exemption
    from its specification when the input happens to call it.

    "Thus for halt deciders these inference steps
    are restricted to the operational semantics
    of the language of computation of the input."

    NO.

    A halting decider must give answers consistent with the operational
    semantics of its input.

    It need not perform its analysis by executing those operational semantics
    step by step.

    YOU HAVE ALREADY CONCEDED THAT STATIC ANALYSIS CAN ESTABLISH TERMINATION WITHOUT FULL SIMULATION.

    Now you offer two possibilities:

    "(1) The behavior that the input finite string DD
    specifies to its halt decider HHH is non-halting"

    Then you have merely shown that YOUR RECURSIVE SIMULATION DOES NOT
    TERMINATE.

    That is not a decision about the halting behavior of DD under the
    hypothesis of a total, correct HHH.

    You are confusing the behavior of the analyzer with the behavior it is supposed to analyze.

    "(2) [...] DD is rejected as bad input."

    ON WHAT GROUNDS?

    DD is a syntactically valid program.

    Its encoding is a finite string.

    It can be executed under a specified implementation of HHH.

    There is no type error and no malformed term.

    Your Prolog analogy is irrelevant.

    unify_with_occurs_check(X, f(X))

    rejects a cyclic first-order substitution.

    DD IS NOT A CYCLIC FIRST-ORDER SUBSTITUTION.

    A recursive call is not an occurs-check violation.

    And a program calling its own analyzer is not automatically malformed.

    Most importantly, you cannot exclude DD merely because its inclusion would contradict your claim that HHH is a universal decider.

    THAT IS THE VERY CLAIM UNDER EXAMINATION.

    The diagonal argument says:

    ASSUME H IS TOTAL AND CORRECT.

    Construct D using H.

    Since H is total, its call returns.

    Since H is correct, its answer must describe D's actual halting behavior.

    But D deliberately does the opposite.

    CONTRADICTION.

    Your alternatives are:

    - HHH loops while trying to analyze DD.
    - HHH rejects DD as invalid.

    In the first case, HHH is not total.

    In the second, HHH is not a universal halting decider over valid program encodings.

    NEITHER CASE REFUTES THE HALTING THEOREM.

    Both are entirely consistent with it.

    And your newly invented exception rCo

    "EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER"

    rCo is nothing more than an admission that your proposed decider cannot
    handle the diagonal construction.

    THAT IS EXACTLY WHY A UNIVERSAL HALTING DECIDER CANNOT EXIST.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 12:58:56 2026
    From Newsgroup: comp.ai.philosophy

    On 11/15/2026 1:20 AM, dart200 wrote:
    On 11/15/26 12:38 AM, Chris M. Thomasson wrote:
    On 11/15/2026 12:33 AM, dart200 wrote:
    On 11/14/26 11:02 PM, Chris M. Thomasson wrote:
    On 11/12/2026 1:55 PM, dart200 wrote:
    On 11/12/26 12:59 PM, Chris M. Thomasson wrote:
    On 11/12/2026 12:40 PM, dart200 wrote:
    On 11/12/26 12:33 PM, Chris M. Thomasson wrote:
    On 11/11/2026 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are >>>>>>>>>>>>>>> NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years. >>>>>>>>>>>>>> The closest that anyone ever got is showing that my >>>>>>>>>>>>>> words to not conform to their false assumptions.

    I can very much better show that these assumptions >>>>>>>>>>>>>> are false now that I have anchored computable functions >>>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>>> As far as my essence goes I have gotten much more clear >>>>>>>>>>>> about proving the tiny aspects of nuance of details of >>>>>>>>>>>> the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>>> I misunderstood what someone was saying. The essence of >>>>>>>>>>>> my work has simply been progressively refined such that >>>>>>>>>>>> I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>>
    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 }

    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on >>>>>>>>>>> the invariant that HHH not cut DD simulation's short after >>>>>>>>>>> the recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical >>>>>>>>> based on the invariant that HHH not cut DD simulation's short >>>>>>>>> after the initial recursion is demonstrated.

    In reality _traditional_ recursion for too long can/will blast >>>>>>>> the shit out of a threads stack... I made a manual recursion for >>>>>>>> AppleSoft BASIC for fun while trying to port some of my algos to >>>>>>>> it:

    why do u port stuff to BASIC for fun??? Ef2-Ef2-Ef2-

    [...]

    Well, basically to see how portable my algos really are. So far, I >>>>>> have all of my fractals that use recursion, and even some of my n- >>>>>> ary vector fields! Let me get an older screenshot of it, I posted >>>>>> it in a BASIC group over on the FB... Found it:

    https://i.ibb.co/My8QQRdm/image.png

    Can you see it?

    https://i.ibb.co/My8QQRdm/image.png

    wow pretty nuts ...

    but not as crazy as porting them to the typescript static type
    checker!

    https://dev.to/gabrielanhaia/doom-ran-inside-typescripts-type-
    checker- heres-how-types-execute-code-50i1

    maybe u can do that one next


    Well, AppleSoft BASIC is pretty old. If it can go there, which it
    can, well, ahhh. That is good enough for me. I started programming
    with BASIC.

    all turing complete languages are convertible to each other, provably so >>>
    we don't know any way of describing an executable algorithm that is
    more powerful in computability than a turing complete language, that
    therefor can be run on a turing machine

    i'm not sure polcott will ever understand this point to be frank


    Yeah. So I can port it and gain the data. But I also want to plot that
    data.

    what data are you gaining and/or plotting from such an exercise?


    It basically boils down to points in an n-ary space to draw field lines
    on a segment by segment basis. For instance, say, this 2-ary example:

    https://youtu.be/poXeq5V0dso
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 21:11:14 2026
    From Newsgroup: comp.ai.philosophy

    On 11/15/2026 2:14 PM, Python wrote:
    Le 15/11/2026 |a 15:11, olcott a |-crit :
    On 11/15/2026 5:37 AM, Python wrote:
    Le 15/11/2026 |a 04:38, olcott a |-crit :
    On 11/14/2026 11:02 AM, Python wrote:
    Peter,

    We have finally made some progress.

    You explicitly concede:

    -a-a-a "I will grant you that."

    And:

    -a-a-a "Yes I will grant you that."

    In particular, you now acknowledge that static analysis can
    establish termination WITHOUT executing every step of the program.

    GOOD.


    I knew that.

    But then you write:

    -a-a-a "These are all simply short cuts to reduce the
    -a-a-a-a time that it takes to perform an actual simulation."

    NO.


    It is only behavior that is consistent with the behavior
    of input I simulated by H that measures the behavior of
    I AS AN INPUT TO H.

    A mathematical proof of termination is not necessarily an
    abbreviated simulation.

    It can establish a property of ALL possible executions without
    reconstructing ANY complete execution trace.


    An input that takes no arguments eliminates the
    Frederick Brooks (No Silver Bullet Essence and
    Accidents of Software Engineering) inessential
    complexity of an input with arguments.

    You are confusing reasoning ABOUT a computation with PERFORMING
    that computation.

    -a-a-a "These short-cuts must remain consistent with
    -a-a-a-a what the behavior of the simulation would be"

    OF COURSE.

    That is called CORRECTNESS.


    Great we are back to mutual agreement.
    DD simulated by HHH provides the ultimate basis of
    the behavior that DD (AS AN INPUT) specifies to HHH.

    Deciders apply finite string transformation /
    inference steps to finite string inputs according
    to a decision criteria.

    It does not imply that the analysis must simulate the program.

    Now to your latest escape hatch:

    -a-a-a "Type mismatch error."

    WHAT TYPE MISMATCH?

    The halting problem concerns encoded programs and their inputs.

    A hypothetical universal decider H accepts such encodings and
    returns a Boolean answer.

    The diagonal program D is itself a valid program.

    Its encoding is a valid input to H.

    And D calls H on that encoding.

    THERE IS NO TYPE MISMATCH.


    The type mismatch is the expectation that HHH
    reports on the behavior of the executable
    process DD() instead of the behavior that the
    finite string (AS AN INPUT) specifies to HHH.

    Here is the argument, stripped of every irrelevant implementation
    detail.

    Assume H is total and correct.

    Define D(x) as follows:

    -a-a-a if H(x, x) says "halts":
    -a-a-a-a-a-a-a loop forever
    -a-a-a else:
    -a-a-a-a-a-a-a halt

    Now consider D(D).

    If H(D, D) says "halts", D(D) does not halt.

    If H(D, D) says "does not halt", D(D) halts.

    CONTRADICTION.

    // eliminate inessential argument to DD

    typedef int (*ptr)();
    int HHH(ptr P);

    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 }
    08
    09 void main()
    10 {
    11-a HHH(DD);
    12 }

    Simulation Trace
    Line 11: main() invokes HHH(DD);

    Line 03: DD calls HHH(DD); HHH simulates DD;
    -a Line 03: DD calls HHH(DD); HHH simulates DD;
    -a-a Line 03: DD calls HHH(DD); HHH simulates DD;
    -a-a-a Line 03: DD calls HHH(DD); HHH simulates DD; ...

    <snip>

    Peter,

    -a-a-a "The type mismatch is the expectation that HHH
    -a-a-a-a reports on the behavior of the executable
    -a-a-a-a process DD() instead of the behavior that the
    -a-a-a-a finite string (AS AN INPUT) specifies to HHH."

    THERE IS NO TYPE MISMATCH.

    A program's encoding is a finite string.

    That string describes a program.

    The program has an operational semantics.

    And the halting problem asks whether the computation described by
    that encoding terminates.


    It asks about the behavior of a machine that no
    halt decider has direct access to.

    The finite string encoding of the machine (as an input)
    does specify the behavior of the static finite string
    input EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER,
    otherwise it is a valid proxy for the behavior of the
    underlying machine.

    **Computation defined**
    Turing equivalent Post canonical systems and semi-Thue
    systems are simplified and made generic as follows:

    All Turing equivalent computations can be reduced to
    applying finite string transformation rules to finite
    string inputs to derive any and all outputs.

    Deciders only apply finite string transformation/inference
    steps to their finite strings AS INPUTS.

    They must only apply inference steps that are relevant
    to the decision criterion.

    Thus for halt deciders these inference steps are restricted
    to the operational semantics of the language of computation
    of the input.


    THAT IS THE ENTIRE POINT OF ENCODING PROGRAMS.

    You are inventing a distinction between the behavior of a program and
    the behavior specified by its encoding.

    Those are not two different decision problems.

    Now consider your simulation trace:

    -a-a-a main() calls HHH(DD)
    -a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ...

    YES, PETER.

    YOUR HHH GETS STUCK IN INFINITE RECURSION.

    CONGRATULATIONS.

    YOU HAVE DEMONSTRATED THAT YOUR HHH IS NOT A TOTAL HALTING DECIDER.


    There are at least two ways that this can be correctly understood:
    (1) The behavior that the the input finite string DD
    specifies to its halt decider HHH is non-halting behavior.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    (2) When we hypothesize that HHH is applying a Prolog
    unify_with_occurs_check() to its input the DD is rejected
    as bad input. I report this one because it is exactly the
    same process as unify_with_occurs_check(LP, not(true(LP))).

    That is perfectly consistent with the Halting Theorem.

    In fact, it is exactly the kind of failure the theorem tells us is
    unavoidable for any proposed universal decider.

    But the diagonal proof does not assume that H works by recursively
    simulating its input.

    IT ASSUMES THAT H IS TOTAL AND CORRECT.

    Under that hypothesis, H(DD) returns an answer.

    Therefore DD reaches its conditional branch.

    And whichever answer H returns, DD does the opposite.

    THAT IS THE CONTRADICTION.

    You cannot refute a proof about ALL possible computable deciders by
    exhibiting ONE PARTICULAR DECIDER THAT FAILS.

    And your attempt to make the simulator's behavior the "ultimate
    basis" of the program's semantics is circular.

    A simulator is supposed to reproduce the semantics of the program.

    THE SEMANTICS IS NOT DEFINED BY WHETHER YOUR SIMULATOR SUCCEEDS.


    The semantics is the operational semantics of C applied
    to the decision criteria as inference steps.

    If your simulator gets stuck, that tells us something about your
    simulator.

    It does not establish that the program is invalid.

    Nor does it establish that a hypothetical total H could avoid the
    diagonal contradiction.

    Your entire argument amounts to:

    "My implementation of H cannot decide D."

    YES.

    THAT IS WHAT THE HALTING THEOREM PREDICTS.

    You have spent 28 years demonstrating an example of the theorem you
    claim to have refuted.

    Peter,

    -a-a "The finite string encoding of the machine
    -a-a-a does specify the behavior [...] EXCEPT WHEN
    -a-a-a THE INPUT CALLS ITS OWN DECIDER"

    THERE IT IS.

    YOUR ENTIRE "REFUTATION" IN ONE SENTENCE.

    You accept that program encodings describe program behavior.


    That is not perfectly exactly what I said.
    the nuances of detail are crucial.

    Finite strings are incorrectly assumed to always be a
    valid proxy for the behavior of the underlying computation.
    They are NOT IN FACT ALWAYS SUCH A VALID PROXY.

    AND IT HAS ALWAYS ONLY EVER BEEN THE BEHAVIOR THAT
    THE FINITE STRING SPECIFIES *AS AN INPUT* THAT THE
    DECIDER IS ACCOUNTABLE FOR.

    The rest of what you say is anchored in your bad paraphrase.
    The rest of what you say is anchored in your bad paraphrase.
    The rest of what you say is anchored in your bad paraphrase.

    EXCEPT WHEN DIAGONALIZATION BECOMES INCONVENIENT.

    That exception is not a theorem.

    It is something you have INVENTED to escape the contradiction.

    A program does not become invalid merely because it calls another
    program that analyzes it.

    And a hypothetical total halting decider does not acquire an exemption
    from its specification when the input happens to call it.

    -a-a "Thus for halt deciders these inference steps
    -a-a-a are restricted to the operational semantics
    -a-a-a of the language of computation of the input."

    NO.

    A halting decider must give answers consistent with the operational semantics of its input.


    That is what just said.

    It need not perform its analysis by executing those operational
    semantics step by step.


    We already agreed on that.

    YOU HAVE ALREADY CONCEDED THAT STATIC ANALYSIS CAN ESTABLISH TERMINATION WITHOUT FULL SIMULATION.


    Yet it must be consistent with the halting behavior
    that is specified by the fill simulation.

    Now you offer two possibilities:

    -a-a "(1) The behavior that the input finite string DD
    -a-a-a specifies to its halt decider HHH is non-halting"

    Then you have merely shown that YOUR RECURSIVE SIMULATION DOES NOT TERMINATE.

    That is not a decision about the halting behavior of DD under the
    hypothesis of a total, correct HHH.


    It is a a decision based on HHH applying inference
    steps to its finite string input DD according to the
    operational semantics of C.

    You are confusing the behavior of the analyzer with the behavior it is supposed to analyze.

    -a-a "(2) [...] DD is rejected as bad input."

    ON WHAT GROUNDS?


    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    These exact same grounds.

    DD is a syntactically valid program.

    Its encoding is a finite string.

    It can be executed under a specified implementation of HHH.

    There is no type error and no malformed term.

    Your Prolog analogy is irrelevant.

    -a-a unify_with_occurs_check(X, f(X))

    rejects a cyclic first-order substitution.


    Rejects all expressions that are semantically ungrounded.
    When expressions of language are defined on the basis of
    other expressions of language then any unconditional cycle
    in this resolution proves that the original expression
    never gets to its meaning.

    DD IS NOT A CYCLIC FIRST-ORDER SUBSTITUTION.

    A recursive call is not an occurs-check violation.

    And a program calling its own analyzer is not automatically malformed.

    Most importantly, you cannot exclude DD merely because its inclusion
    would contradict your claim that HHH is a universal decider.


    The HHH(DD)==0 is correct is proved true on the basis
    of HHH applying the most relevant inference steps to
    its INPUT DD (as an input).

    We can interpret this DD specifies behavior to HHH
    such that this input DD cannot possibly reach its
    own final state. THAT IS THE OBJECTIVE TRUTH.

    The rest is simply you not paying close enough
    attention to this:

    Computation defined
    Turing equivalent Post canonical systems and semi-Thue
    systems are simplified and made generic as follows:

    All Turing equivalent computations can be reduced to
    applying finite string transformation rules to finite string
    inputs to derive any and all outputs.

    Deciders only apply finite string transformation/inference
    steps to their finite strings AS INPUTS.

    They must only apply inference steps that are relevant to
    the decision criterion.

    Thus for halt deciders these inference steps are restricted
    to the operational semantics of the language of computation
    of the input.

    Simulation Trace
    Line 11: main() invokes HHH(DD);
    Line 03: DD calls HHH(DD); HHH simulates DD;
    Line 03: DD calls HHH(DD); HHH simulates DD;
    Line 03: DD calls HHH(DD); HHH simulates DD;
    Line 03: DD calls HHH(DD); HHH simulates DD;

    THAT IS THE VERY CLAIM UNDER EXAMINATION.

    The diagonal argument says:

    ASSUME H IS TOTAL AND CORRECT.

    Construct D using H.

    Since H is total, its call returns.

    Since H is correct, its answer must describe D's actual halting behavior.

    But D deliberately does the opposite.

    CONTRADICTION.

    Your alternatives are:

    - HHH loops while trying to analyze DD.
    - HHH rejects DD as invalid.

    In the first case, HHH is not total.

    In the second, HHH is not a universal halting decider over valid program encodings.

    NEITHER CASE REFUTES THE HALTING THEOREM.

    Both are entirely consistent with it.

    And your newly invented exception rCo

    -a-a "EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER"

    rCo is nothing more than an admission that your proposed decider cannot handle the diagonal construction.

    THAT IS EXACTLY WHY A UNIVERSAL HALTING DECIDER CANNOT EXIST.
    --
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy on Sun Nov 15 20:33:07 2026
    From Newsgroup: comp.ai.philosophy

    On 11/15/26 7:11 PM, olcott wrote:
    On 11/15/2026 2:14 PM, Python wrote:
    Le 15/11/2026 |a 15:11, olcott a |-crit :
    On 11/15/2026 5:37 AM, Python wrote:
    Le 15/11/2026 |a 04:38, olcott a |-crit :
    On 11/14/2026 11:02 AM, Python wrote:
    Peter,

    We have finally made some progress.

    You explicitly concede:

    -a-a-a "I will grant you that."

    And:

    -a-a-a "Yes I will grant you that."

    In particular, you now acknowledge that static analysis can
    establish termination WITHOUT executing every step of the program. >>>>>>
    GOOD.


    I knew that.

    But then you write:

    -a-a-a "These are all simply short cuts to reduce the
    -a-a-a-a time that it takes to perform an actual simulation."

    NO.


    It is only behavior that is consistent with the behavior
    of input I simulated by H that measures the behavior of
    I AS AN INPUT TO H.

    A mathematical proof of termination is not necessarily an
    abbreviated simulation.

    It can establish a property of ALL possible executions without
    reconstructing ANY complete execution trace.


    An input that takes no arguments eliminates the
    Frederick Brooks (No Silver Bullet Essence and
    Accidents of Software Engineering) inessential
    complexity of an input with arguments.

    You are confusing reasoning ABOUT a computation with PERFORMING
    that computation.

    -a-a-a "These short-cuts must remain consistent with
    -a-a-a-a what the behavior of the simulation would be"

    OF COURSE.

    That is called CORRECTNESS.


    Great we are back to mutual agreement.
    DD simulated by HHH provides the ultimate basis of
    the behavior that DD (AS AN INPUT) specifies to HHH.

    Deciders apply finite string transformation /
    inference steps to finite string inputs according
    to a decision criteria.

    It does not imply that the analysis must simulate the program.

    Now to your latest escape hatch:

    -a-a-a "Type mismatch error."

    WHAT TYPE MISMATCH?

    The halting problem concerns encoded programs and their inputs.

    A hypothetical universal decider H accepts such encodings and
    returns a Boolean answer.

    The diagonal program D is itself a valid program.

    Its encoding is a valid input to H.

    And D calls H on that encoding.

    THERE IS NO TYPE MISMATCH.


    The type mismatch is the expectation that HHH
    reports on the behavior of the executable
    process DD() instead of the behavior that the
    finite string (AS AN INPUT) specifies to HHH.

    Here is the argument, stripped of every irrelevant implementation >>>>>> detail.

    Assume H is total and correct.

    Define D(x) as follows:

    -a-a-a if H(x, x) says "halts":
    -a-a-a-a-a-a-a loop forever
    -a-a-a else:
    -a-a-a-a-a-a-a halt

    Now consider D(D).

    If H(D, D) says "halts", D(D) does not halt.

    If H(D, D) says "does not halt", D(D) halts.

    CONTRADICTION.

    // eliminate inessential argument to DD

    typedef int (*ptr)();
    int HHH(ptr P);

    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 }
    08
    09 void main()
    10 {
    11-a HHH(DD);
    12 }

    Simulation Trace
    Line 11: main() invokes HHH(DD);

    Line 03: DD calls HHH(DD); HHH simulates DD;
    -a Line 03: DD calls HHH(DD); HHH simulates DD;
    -a-a Line 03: DD calls HHH(DD); HHH simulates DD;
    -a-a-a Line 03: DD calls HHH(DD); HHH simulates DD; ...

    <snip>

    Peter,

    -a-a-a "The type mismatch is the expectation that HHH
    -a-a-a-a reports on the behavior of the executable
    -a-a-a-a process DD() instead of the behavior that the
    -a-a-a-a finite string (AS AN INPUT) specifies to HHH."

    THERE IS NO TYPE MISMATCH.

    A program's encoding is a finite string.

    That string describes a program.

    The program has an operational semantics.

    And the halting problem asks whether the computation described by
    that encoding terminates.


    It asks about the behavior of a machine that no
    halt decider has direct access to.

    The finite string encoding of the machine (as an input)
    does specify the behavior of the static finite string
    input EXCEPT WHEN THE INPUT CALLS ITS OWN DECIDER,
    otherwise it is a valid proxy for the behavior of the
    underlying machine.

    **Computation defined**
    Turing equivalent Post canonical systems and semi-Thue
    systems are simplified and made generic as follows:

    All Turing equivalent computations can be reduced to
    applying finite string transformation rules to finite
    string inputs to derive any and all outputs.

    Deciders only apply finite string transformation/inference
    steps to their finite strings AS INPUTS.

    They must only apply inference steps that are relevant
    to the decision criterion.

    Thus for halt deciders these inference steps are restricted
    to the operational semantics of the language of computation
    of the input.


    THAT IS THE ENTIRE POINT OF ENCODING PROGRAMS.

    You are inventing a distinction between the behavior of a program
    and the behavior specified by its encoding.

    Those are not two different decision problems.

    Now consider your simulation trace:

    -a-a-a main() calls HHH(DD)
    -a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a DD calls HHH(DD)
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a ...

    YES, PETER.

    YOUR HHH GETS STUCK IN INFINITE RECURSION.

    CONGRATULATIONS.

    YOU HAVE DEMONSTRATED THAT YOUR HHH IS NOT A TOTAL HALTING DECIDER.


    There are at least two ways that this can be correctly understood:
    (1) The behavior that the the input finite string DD
    specifies to its halt decider HHH is non-halting behavior.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    (2) When we hypothesize that HHH is applying a Prolog
    unify_with_occurs_check() to its input the DD is rejected
    as bad input. I report this one because it is exactly the
    same process as unify_with_occurs_check(LP, not(true(LP))).

    That is perfectly consistent with the Halting Theorem.

    In fact, it is exactly the kind of failure the theorem tells us is
    unavoidable for any proposed universal decider.

    But the diagonal proof does not assume that H works by recursively
    simulating its input.

    IT ASSUMES THAT H IS TOTAL AND CORRECT.

    Under that hypothesis, H(DD) returns an answer.

    Therefore DD reaches its conditional branch.

    And whichever answer H returns, DD does the opposite.

    THAT IS THE CONTRADICTION.

    You cannot refute a proof about ALL possible computable deciders by
    exhibiting ONE PARTICULAR DECIDER THAT FAILS.

    And your attempt to make the simulator's behavior the "ultimate
    basis" of the program's semantics is circular.

    A simulator is supposed to reproduce the semantics of the program.

    THE SEMANTICS IS NOT DEFINED BY WHETHER YOUR SIMULATOR SUCCEEDS.


    The semantics is the operational semantics of C applied
    to the decision criteria as inference steps.

    If your simulator gets stuck, that tells us something about your
    simulator.

    It does not establish that the program is invalid.

    Nor does it establish that a hypothetical total H could avoid the
    diagonal contradiction.

    Your entire argument amounts to:

    "My implementation of H cannot decide D."

    YES.

    THAT IS WHAT THE HALTING THEOREM PREDICTS.

    You have spent 28 years demonstrating an example of the theorem you
    claim to have refuted.

    Peter,

    -a-a-a "The finite string encoding of the machine
    -a-a-a-a does specify the behavior [...] EXCEPT WHEN
    -a-a-a-a THE INPUT CALLS ITS OWN DECIDER"

    THERE IT IS.

    YOUR ENTIRE "REFUTATION" IN ONE SENTENCE.

    You accept that program encodings describe program behavior.


    That is not perfectly exactly what I said.
    the nuances of detail are crucial.

    Finite strings are incorrectly assumed to always be a
    valid proxy for the behavior of the underlying computation.
    They are NOT IN FACT ALWAYS SUCH A VALID PROXY.

    a random finite string has no "halting semantics" polcott

    only a finite string that specifies a valid turing machine has a
    "halting semantics" that can be the mapped to in a valid manner, and we
    cannot compute that mapping across all possible finite strings with a
    single decider
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2