• Re: Next step after the C portion of my halting theorem refutation

    From Python@python@cccp.invalid to comp.theory,sci.logic on Tue Nov 3 01:00:46 2026
    From Newsgroup: sci.logic

    Le 03/11/2026 |a 01:51, olcott a |-crit :
    On 11/2/2026 3:43 PM, Python wrote:
    You JUST admitted it:

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


    That is the hole in your argument.

    And no, these two statements do NOT mean "exactly the same thing":

    -a-a WHILE HHH continues simulating DD,
    -a-a DD does not reach its return.

    and:

    -a-a DD WOULD NEVER stop running UNLESS aborted.

    The first says what happens DURING the simulation.

    The second says what would happen FOREVER if the simulation were NOT
    aborted.

    That fucking "NEVER" is precisely what you have not established.

    You cannot repair the missing proof by simply declaring:

    -a-a WHILE = NEVER UNLESS ABORTED

    They are not logically equivalent.

    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    When HHH does verify that this above paragraph conditions
    have been met:

    *its simulated DD would never stop running unless aborted*

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


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

    *by substituting synonymous terms*
    stops running == HALT
    reaches its return == HALT
    aborted means stops being simulated

    *Deriving these two equivalent statements*
    its simulated DD would never HALT unless stops being simulated
    WHILE THE SIMULATION CONTINUES, DD DOES NOT HALT.

    NO, Peter. This is now pure circular bullshit.

    You write:

    "When HHH does verify that these above paragraph
    conditions have been met"

    STOP RIGHT FUCKING THERE.

    THAT IS THE THING YOU HAVE NOT PROVED.

    Sipser's premise is:

    H CORRECTLY DETERMINES that D
    WOULD NEVER stop running unless aborted.

    Your established statement is:

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

    And now you claim they are equivalent by "substituting synonymous terms."

    They fucking aren't.

    The vocabulary is not the problem.

    Yes:

    stops running ~= halts
    reaches its return ~= halts
    aborted ~= stops being simulated

    None of those substitutions manufactures the missing temporal quantifier:

    NEVER.

    Let's strip away every distracting word.

    You have:

    WHILE X, NOT Y.

    You need:

    IF X IS NEVER TERMINATED, Y NEVER OCCURS.

    Those are NOT equivalent merely by substituting synonyms.

    The first describes what is true while X continues.

    The second makes a claim about the ENTIRE hypothetical future in which X continues indefinitely.

    THAT IS THE FUCKING PROPOSITION YOU HAVE TO PROVE.

    And your latest argument is literally:

    1. IF H correctly determines NEVER, Sipser says the result is correct.

    2. Assume HHH has verified that condition.

    3. Therefore HHH has correctly determined NEVER.

    That is not a proof.

    THAT IS ASSUMING THE FUCKING PREMISE.

    Worse, you JUST admitted this yourself:

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

    Correct.

    IF.

    So stop quoting Sipser.
    Stop substituting synonyms.
    Stop repeating my qualified agreement.
    Stop declaring the unproved condition "verified."

    SHOW THE INFERENCE:

    WHILE HHH SIMULATES DD,
    DD HAS NOT HALTED

    |
    | PROVE THIS FUCKING ARROW
    v

    IF HHH CONTINUED SIMULATING DD FOREVER,
    DD WOULD NEVER HALT.

    Until you prove that arrow, you have not established Sipser's premise.

    You have merely written the conclusion you need into the phrase:

    "HHH does verify"

    and then congratulated yourself for deriving it.

    That is textbook begging the question.


    AND ONE MORE THING:

    STOP USING MY QUOTATION AS IF IT SUPPORTED YOUR STRONGER CLAIM.

    I have now told you REPEATEDLY and EXPLICITLY that my agreement is limited
    to:

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

    I explicitly DO NOT agree that this entails:

    DD WOULD NEVER HALT UNLESS ABORTED.

    Yet you keep quoting my words immediately before asserting YOUR purported equivalence, creating the impression that my agreement lends support to
    it.

    IT DOES NOT.

    You have been corrected about this too many times for "misunderstanding"
    to remain a credible excuse.

    Quote me if necessary to preserve the thread context.

    But DO NOT PRESENT MY WORDS AS EVIDENCE, AGREEMENT, CONSENSUS, OR SUPPORT
    FOR YOUR "NEVER UNLESS ABORTED" CLAIM.

    That claim is YOURS.

    The missing proof is YOURS.

    My name does not belong on it.


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

    On 11/2/2026 7:00 PM, Python wrote:
    Le 03/11/2026 |a 01:51, olcott a |-crit :

    *Deriving these two equivalent statements*
    its simulated DD would never HALT unless stops being simulated
    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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Mon Nov 2 17:14:11 2026
    From Newsgroup: sci.logic

    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring some >>>>>>>>>>>>>> uniquely profound understanding of the "foundations of >>>>>>>>>>>>>> computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does

    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the
    conclusion rests upon a statement made by some presumed authority or
    witness... Because the testimony of a qualified authority or witness
    provides a reason for believing a claim, such arguments are often
    inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_

    the "then" refers to aborting after the recursion is detected. sipser
    provides an exception to the correctness of the decision, explicitly if
    the simulation is _then_ aborted after the determination is made. this
    is what HHH does, and therefore the analysis by HHH of DD is invalidated

    it sucks to be wrong polcott, but it's better to admit ur wrong than
    continue being wrong, this is know from experience
    --
    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,alt.messianic,alt.buddha.short.fat.guy on Mon Nov 2 19:17:51 2026
    From Newsgroup: sci.logic

    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring some >>>>>>>>>>>>>>> uniquely profound understanding of the "foundations of >>>>>>>>>>>>>>> computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does

    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the
    conclusion rests upon a statement made by some presumed authority or
    witness... Because the testimony of a qualified authority or witness
    provides a reason for believing a claim, such arguments are often
    inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    --
    Copyright 2026 Olcott

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

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

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

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

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

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

    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring some >>>>>>>>>>>>>>> uniquely profound understanding of the "foundations of >>>>>>>>>>>>>>> computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does

    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the
    conclusion rests upon a statement made by some presumed authority or
    witness... Because the testimony of a qualified authority or witness
    provides a reason for believing a claim, such arguments are often
    inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_

    DD simulated by HHH WOULD NEVER stop running UNLESS aborted.
    stops running == HALT
    reaches its return == HALT
    aborted means stops being simulated

    becomes
    its simulated DD would never HALT unless stops being simulated

    equivalent to this:
    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 olcott@polcott333@gmail.com to comp.theory,sci.logic on Mon Nov 2 20:00:38 2026
    From Newsgroup: sci.logic

    On 11/2/2026 7:00 PM, Python wrote:
    Le 03/11/2026 |a 01:51, olcott a |-crit :
    On 11/2/2026 3:43 PM, Python wrote:
    You JUST admitted it:

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


    That is the hole in your argument.

    And no, these two statements do NOT mean "exactly the same thing":

    -a-a-a WHILE HHH continues simulating DD,
    -a-a-a DD does not reach its return.

    and:

    -a-a-a DD WOULD NEVER stop running UNLESS aborted.

    The first says what happens DURING the simulation.

    The second says what would happen FOREVER if the simulation were NOT
    aborted.

    That fucking "NEVER" is precisely what you have not established.

    You cannot repair the missing proof by simply declaring:

    -a-a-a WHILE = NEVER UNLESS ABORTED

    They are not logically equivalent.

    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    When HHH does verify that this above paragraph conditions
    have been met:

    *its simulated DD would never stop running unless aborted*

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


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

    *by substituting synonymous terms*
    stops running == HALT
    reaches its return == HALT
    aborted means stops being simulated

    *Deriving these two equivalent statements*
    its simulated DD would never HALT unless stops being simulated
    WHILE THE SIMULATION CONTINUES, DD DOES NOT HALT.

    NO, Peter. This is now pure circular bullshit.

    You write:

    -a-a "When HHH does verify that these above paragraph
    -a-a-a conditions have been met"

    STOP RIGHT FUCKING THERE.

    THAT IS THE THING YOU HAVE NOT PROVED.

    Sipser's premise is:

    -a-a H CORRECTLY DETERMINES that D
    -a-a WOULD NEVER stop running unless aborted.

    Your established statement is:

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

    And now you claim they are equivalent by "substituting synonymous terms."

    They fucking aren't.

    The vocabulary is not the problem.

    Yes:

    -a-a stops running ~= halts
    -a-a reaches its return ~= halts
    -a-a aborted ~= stops being simulated

    None of those substitutions manufactures the missing temporal quantifier:

    -a-a NEVER.

    Let's strip away every distracting word.

    You have:

    -a-a WHILE X, NOT Y.

    You need:

    -a-a IF X IS NEVER TERMINATED, Y NEVER OCCURS.

    Those are NOT equivalent merely by substituting synonyms.

    The first describes what is true while X continues.

    The second makes a claim about the ENTIRE hypothetical future in which X continues indefinitely.

    THAT IS THE FUCKING PROPOSITION YOU HAVE TO PROVE.

    And your latest argument is literally:

    -a-a 1. IF H correctly determines NEVER, Sipser says the result is correct.

    -a-a 2. Assume HHH has verified that condition.

    -a-a 3. Therefore HHH has correctly determined NEVER.

    That is not a proof.

    THAT IS ASSUMING THE FUCKING PREMISE.

    Worse, you JUST admitted this yourself:

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

    Correct.

    IF.

    So stop quoting Sipser.
    Stop substituting synonyms.
    Stop repeating my qualified agreement.
    Stop declaring the unproved condition "verified."

    SHOW THE INFERENCE:

    -a-a WHILE HHH SIMULATES DD,
    -a-a DD HAS NOT HALTED

    -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 PROVE THIS FUCKING ARROW
    -a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a v

    -a-a IF HHH CONTINUED SIMULATING DD FOREVER,
    -a-a DD WOULD NEVER HALT.

    Until you prove that arrow, you have not established Sipser's premise.

    You have merely written the conclusion you need into the phrase:

    -a-a "HHH does verify"

    and then congratulated yourself for deriving it.

    That is textbook begging the question.


    AND ONE MORE THING:

    STOP USING MY QUOTATION AS IF IT SUPPORTED YOUR STRONGER CLAIM.

    I have now told you REPEATEDLY and EXPLICITLY that my agreement is
    limited to:

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

    I explicitly DO NOT agree that this entails:

    -a-a DD WOULD NEVER HALT UNLESS ABORTED.

    Yet you keep quoting my words immediately before asserting YOUR
    purported equivalence, creating the impression that my agreement lends support to it.

    IT DOES NOT.

    You have been corrected about this too many times for "misunderstanding"
    to remain a credible excuse.

    Quote me if necessary to preserve the thread context.

    But DO NOT PRESENT MY WORDS AS EVIDENCE, AGREEMENT, CONSENSUS, OR
    SUPPORT FOR YOUR "NEVER UNLESS ABORTED" CLAIM.

    That claim is YOURS.

    The missing proof is YOURS.

    My name does not belong on it.

    DD simulated by HHH WOULD NEVER stop running UNLESS aborted.
    stops running == HALT
    reaches its return == HALT
    aborted means stops being simulated

    becomes
    its simulated DD would never HALT unless stops being simulated

    equivalent to this:
    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 olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.lang.c,comp.lang.c++ on Mon Nov 2 20:54:27 2026
    From Newsgroup: sci.logic

    On 11/1/2026 8:09 PM, Mike Terry wrote:
    On 02/11/2026 00:36, Python wrote:
    You have STILL advanced exactly ZERO steps.

    You started with:

    -a-a-a simulated DD never reaches its final return state
    -a-a-a in any finite number of steps

    and now conclude:

    -a-a-a simulated DD never halts
    -a-a-a in any finite number of steps

    because "halting" means reaching a final state.

    Fine.

    THAT IS STILL THE SAME FUCKING PROPOSITION.

    Now comes the part you keep avoiding:

    How does HHH, which is supposed to be a HALT DECIDER, terminate and
    return 0 to DD?

    If HHH(DD) never returns, then HHH is not a terminating halt decider
    on DD.

    If HHH(DD) returns 0, then DD executes:

    -a-a-a return Halt_Status;

    and halts.

    If HHH(DD) returns 1, DD loops.

    Those are the three cases.

    So your endless rewriting of:

    -a-a-a "DD does not reach its final state while HHH keeps simulating it"

    does not refute the Halting Theorem.

    It merely describes the case in which HHH DOES NOT RETURN.

    I'm not sure you're understanding the situation correctly...

    I mean, "DD does not reach its final state while HHH keeps simulating
    it" correctly describes the situation where HHH never aborts,

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

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.
    --
    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 Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Mon Nov 2 19:34:22 2026
    From Newsgroup: sci.logic

    On 11/2/2026 5:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring some >>>>>>>>>>>>>>> uniquely profound understanding of the "foundations of >>>>>>>>>>>>>>> computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does

    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the
    conclusion rests upon a statement made by some presumed authority or
    witness... Because the testimony of a qualified authority or witness
    provides a reason for believing a claim, such arguments are often
    inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_

    the "then" refers to aborting after the recursion is detected. sipser provides an exception to the correctness of the decision, explicitly if
    the simulation is _then_ aborted after the determination is made. this
    is what HHH does, and therefore the analysis by HHH of DD is invalidated

    it sucks to be wrong polcott, but it's better to admit ur wrong than continue being wrong, this is know from experience

    It kind of looks like you just posted an appeal to authority - Alan Turing.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Mon Nov 2 21:37:28 2026
    From Newsgroup: sci.logic

    On 11/2/2026 9:34 PM, Dude wrote:
    On 11/2/2026 5:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring some >>>>>>>>>>>>>>>> uniquely profound understanding of the "foundations of >>>>>>>>>>>>>>>> computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does

    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the
    conclusion rests upon a statement made by some presumed authority
    or witness... Because the testimony of a qualified authority or
    witness provides a reason for believing a claim, such arguments are >>>>> often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_

    the "then" refers to aborting after the recursion is detected. sipser
    provides an exception to the correctness of the decision, explicitly
    if the simulation is _then_ aborted after the determination is made.
    this is what HHH does, and therefore the analysis by HHH of DD is
    invalidated

    it sucks to be wrong polcott, but it's better to admit ur wrong than
    continue being wrong, this is know from experience

    It kind of looks like you just posted an appeal to authority - Alan Turing.

    An appeal to a qualified expert is inductively strong.
    Why the Hell do you cross post to those two groups?
    I am about to give up on you as an insincere troll.
    --
    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,alt.messianic,alt.buddha.short.fat.guy on Mon Nov 2 21:08:36 2026
    From Newsgroup: sci.logic

    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring some >>>>>>>>>>>>>>>> uniquely profound understanding of the "foundations of >>>>>>>>>>>>>>>> computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does

    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the
    conclusion rests upon a statement made by some presumed authority
    or witness... Because the testimony of a qualified authority or
    witness provides a reason for believing a claim, such arguments are >>>>> often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted then*

    ur actively ignoring the conditional on the proof, which is that H is
    correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes prior to
    the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going to
    try to post helpful comments polcott. and i suggest that ignoring the conditional is a major flaw in what ur trying to propose atm
    --
    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,alt.messianic,alt.buddha.short.fat.guy on Mon Nov 2 21:16:05 2026
    From Newsgroup: sci.logic

    On 11/2/2026 5:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring some >>>>>>>>>>>>>>> uniquely profound understanding of the "foundations of >>>>>>>>>>>>>>> computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does

    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the
    conclusion rests upon a statement made by some presumed authority or
    witness... Because the testimony of a qualified authority or witness
    provides a reason for believing a claim, such arguments are often
    inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_

    the "then" refers to aborting after the recursion is detected. sipser provides an exception to the correctness of the decision, explicitly if
    the simulation is _then_ aborted after the determination is made. this
    is what HHH does, and therefore the analysis by HHH of DD is invalidated

    it sucks to be wrong polcott, but it's better to admit ur wrong than continue being wrong, this is know from experience


    Sage advice.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Mon Nov 2 23:24:54 2026
    From Newsgroup: sci.logic

    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the >>>>>> conclusion rests upon a statement made by some presumed authority >>>>>> or witness... Because the testimony of a qualified authority or
    witness provides a reason for believing a claim, such arguments
    are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted then*


    That is a completely dishonest paraphrase.
    I spent two years coming up with those words
    knowing his phone number the whole time. I
    did not call until I got them right.

    ur actively ignoring the conditional on the proof, which is that H is correct if and only if D is then not aborted...


    its simulated DD would never HALT unless stops being simulated

    HHH aborts DD's simulation, so therefore the analysis HHH makes prior to
    the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going to
    try to post helpful comments polcott. and i suggest that ignoring the conditional is a major flaw in what ur trying to propose atm

    --
    Copyright 2026 Olcott

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

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

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

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

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

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

    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the >>>>>> conclusion rests upon a statement made by some presumed authority >>>>>> or witness... Because the testimony of a qualified authority or
    witness provides a reason for believing a claim, such arguments
    are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted then*

    ur actively ignoring the conditional on the proof, which is that H is correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes prior to
    the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going to
    try to post helpful comments polcott. and i suggest that ignoring the conditional is a major flaw in what ur trying to propose atm


    Why the fuck do you add those two groups

    alt.buddha.short.fat.guy
    alt.messianic

    Have you always only been a troll?
    --
    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 on Mon Nov 2 22:11:35 2026
    From Newsgroup: sci.logic

    On 11/2/2026 9:26 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon >>>>>>>>>>>>>> as defined by turing), which is the halting semantics we >>>>>>>>>>>>>> are interested in:

    <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 >>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the >>>>>>> conclusion rests upon a statement made by some presumed authority >>>>>>> or witness... Because the testimony of a qualified authority or >>>>>>> witness provides a reason for believing a claim, such arguments >>>>>>> are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D >>>>>> would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted then*

    ur actively ignoring the conditional on the proof, which is that H is
    correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes prior
    to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going to
    try to post helpful comments polcott. and i suggest that ignoring the
    conditional is a major flaw in what ur trying to propose atm


    Why the fuck do you add those two groups

    alt.buddha.short.fat.guy
    alt.messianic

    Have you always only been a troll?


    Dumb ass...
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Mon Nov 2 23:43:33 2026
    From Newsgroup: sci.logic

    On 11/2/26 9:24 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon >>>>>>>>>>>>>> as defined by turing), which is the halting semantics we >>>>>>>>>>>>>> are interested in:

    <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 >>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the >>>>>>> conclusion rests upon a statement made by some presumed authority >>>>>>> or witness... Because the testimony of a qualified authority or >>>>>>> witness provides a reason for believing a claim, such arguments >>>>>>> are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D >>>>>> would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted then*


    That is a completely dishonest paraphrase.
    I spent two years coming up with those words
    knowing his phone number the whole time. I
    did not call until I got them right.

    ur actively ignoring the conditional on the proof, which is that H is
    correct if and only if D is then not aborted...


    its simulated DD would never HALT unless stops being simulated

    yes DD _would_ never HALT _unless_ HHH aborts it

    _would_ implies a hypothetical based on a conditional, in this case that
    HHH does _not_ abort it

    HHH however does abort DD, violating the required condition (that HHH
    does _not_ abort it) for HHH to truthfully prove that DD is a
    non-terminating machine


    HHH aborts DD's simulation, so therefore the analysis HHH makes prior
    to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going to
    try to post helpful comments polcott. and i suggest that ignoring the
    conditional is a major flaw in what ur trying to propose atm


    --
    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,alt.messianic,alt.buddha.short.fat.guy on Tue Nov 3 00:29:35 2026
    From Newsgroup: sci.logic

    On 11/2/26 9:26 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon >>>>>>>>>>>>>> as defined by turing), which is the halting semantics we >>>>>>>>>>>>>> are interested in:

    <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 >>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the >>>>>>> conclusion rests upon a statement made by some presumed authority >>>>>>> or witness... Because the testimony of a qualified authority or >>>>>>> witness provides a reason for believing a claim, such arguments >>>>>>> are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D >>>>>> would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted then*

    ur actively ignoring the conditional on the proof, which is that H is
    correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes prior
    to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going to
    try to post helpful comments polcott. and i suggest that ignoring the
    conditional is a major flaw in what ur trying to propose atm


    Why the fuck do you add those two groups

    cause i'm hoping u'll actually take this seriously instead of running
    away again tbh???


    alt.buddha.short.fat.guy''

    tbh i kinda hate the dud cons that infest that group. i'm tryin to make
    them less stupid but ya know how trump loving types go eh??? walk around
    with their head up their asshole most of the day denying basic physical
    facts to confirm their endlessly narcissistic biases...

    alt.messianic

    just using it as a personal journal i guess??? Efn+Efn+Efn+


    Have you always only been a troll?

    --
    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 on Tue Nov 3 09:35:56 2026
    From Newsgroup: sci.logic

    On 2026-11-02 19:54, olcott wrote:
    On 11/1/2026 8:09 PM, Mike Terry wrote:
    On 02/11/2026 00:36, Python wrote:
    You have STILL advanced exactly ZERO steps.

    You started with:

    -a-a-a simulated DD never reaches its final return state
    -a-a-a in any finite number of steps

    and now conclude:

    -a-a-a simulated DD never halts
    -a-a-a in any finite number of steps

    because "halting" means reaching a final state.

    Fine.

    THAT IS STILL THE SAME FUCKING PROPOSITION.

    Now comes the part you keep avoiding:

    How does HHH, which is supposed to be a HALT DECIDER, terminate and
    return 0 to DD?

    If HHH(DD) never returns, then HHH is not a terminating halt decider
    on DD.

    If HHH(DD) returns 0, then DD executes:

    -a-a-a return Halt_Status;

    and halts.

    If HHH(DD) returns 1, DD loops.

    Those are the three cases.

    So your endless rewriting of:

    -a-a-a "DD does not reach its final state while HHH keeps simulating it" >>>
    does not refute the Halting Theorem.

    It merely describes the case in which HHH DOES NOT RETURN.

    I'm not sure you're understanding the situation correctly...

    I mean, "DD does not reach its final state while HHH keeps simulating
    it" correctly describes the situation where HHH never aborts,

    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 }

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new
    instance of HHH (call it HHH_1). HHH_1 then simulates a new instance of
    DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.

    Bear in mind that in the above chain, only the outermost HHH counts as 'simulating halt decider H' according to the Sipser criterion. HHH_1,
    HHH_2 and so on are not the halt decider. They are simply part of DD,
    the program under test. And if HHH_1 aborts its input, DD_1, that
    doesn't count as being aborted by the *halt decider*. HHH_1 is simply terminating according to its own rules.

    Your HHH decides it needs to abort DD, but that decision is incorrect
    since if HHH did *not* abort D, HHH_1 invoked inside DD would have
    eventually aborted DD_1, at which point control would be returned to DD
    which would then execute its return instruction.

    So HHH does not *correctly* determine that its input would not terminate unless aborted. It uses incorrect logic to prematurely abort DD.

    If your HHH did not include conditional code to abort its simulating,
    then you would have an infinitely recursive chain. But in that case the outermost HHH would never return a result so it wouldn't count as a halt decider.

    As it stands, your outermost HHH returns nonhalting for an input that
    *is* halting, so it also doesn't count as a halt decider.

    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 on Tue Nov 3 10:47:31 2026
    From Newsgroup: sci.logic

    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:
    On 11/1/2026 8:09 PM, Mike Terry wrote:
    On 02/11/2026 00:36, Python wrote:
    You have STILL advanced exactly ZERO steps.

    You started with:

    -a-a-a simulated DD never reaches its final return state
    -a-a-a in any finite number of steps

    and now conclude:

    -a-a-a simulated DD never halts
    -a-a-a in any finite number of steps

    because "halting" means reaching a final state.

    Fine.

    THAT IS STILL THE SAME FUCKING PROPOSITION.

    Now comes the part you keep avoiding:

    How does HHH, which is supposed to be a HALT DECIDER, terminate and
    return 0 to DD?

    If HHH(DD) never returns, then HHH is not a terminating halt decider
    on DD.

    If HHH(DD) returns 0, then DD executes:

    -a-a-a return Halt_Status;

    and halts.

    If HHH(DD) returns 1, DD loops.

    Those are the three cases.

    So your endless rewriting of:

    -a-a-a "DD does not reach its final state while HHH keeps simulating it" >>>>
    does not refute the Halting Theorem.

    It merely describes the case in which HHH DOES NOT RETURN.

    I'm not sure you're understanding the situation correctly...

    I mean, "DD does not reach its final state while HHH keeps simulating
    it" correctly describes the situation where HHH never aborts,

    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 }

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new
    instance of HHH (call it HHH_1). HHH_1 then simulates a new instance of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    *Proves that this is true*
    If simulating halt decider H correctly simulates its
    input D until [we can see] that its simulated D would
    never stop running unless aborted


    Bear in mind that in the above chain, only the outermost HHH counts as 'simulating halt decider H' according to the Sipser criterion. HHH_1,
    HHH_2 and so on are not the halt decider. They are simply part of DD,
    the program under test. And if HHH_1 aborts its input, DD_1, that
    doesn't count as being aborted by the *halt decider*. HHH_1 is simply terminating according to its own rules.

    Your HHH decides it needs to abort DD, but that decision is incorrect
    since if HHH did *not* abort D, HHH_1 invoked inside DD would have eventually aborted DD_1, at which point control would be returned to DD which would then execute its return instruction.

    So HHH does not *correctly* determine that its input would not terminate unless aborted. It uses incorrect logic to prematurely abort DD.

    If your HHH did not include conditional code to abort its simulating,
    then you would have an infinitely recursive chain. But in that case the outermost HHH would never return a result so it wouldn't count as a halt decider.

    As it stands, your outermost HHH returns nonhalting for an input that
    *is* halting, so it also doesn't count as a halt decider.

    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,alt.messianic,alt.buddha.short.fat.guy on Tue Nov 3 09:44:21 2026
    From Newsgroup: sci.logic

    On 11/3/26 8:47 AM, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:
    On 11/1/2026 8:09 PM, Mike Terry wrote:
    On 02/11/2026 00:36, Python wrote:
    You have STILL advanced exactly ZERO steps.

    You started with:

    -a-a-a simulated DD never reaches its final return state
    -a-a-a in any finite number of steps

    and now conclude:

    -a-a-a simulated DD never halts
    -a-a-a in any finite number of steps

    because "halting" means reaching a final state.

    Fine.

    THAT IS STILL THE SAME FUCKING PROPOSITION.

    Now comes the part you keep avoiding:

    How does HHH, which is supposed to be a HALT DECIDER, terminate and >>>>> return 0 to DD?

    If HHH(DD) never returns, then HHH is not a terminating halt
    decider on DD.

    If HHH(DD) returns 0, then DD executes:

    -a-a-a return Halt_Status;

    and halts.

    If HHH(DD) returns 1, DD loops.

    Those are the three cases.

    So your endless rewriting of:

    -a-a-a "DD does not reach its final state while HHH keeps simulating it" >>>>>
    does not refute the Halting Theorem.

    It merely describes the case in which HHH DOES NOT RETURN.

    I'm not sure you're understanding the situation correctly...

    I mean, "DD does not reach its final state while HHH keeps
    simulating it" correctly describes the situation where HHH never
    aborts,

    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 }

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new
    instance of HHH (call it HHH_1). HHH_1 then simulates a new instance
    of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    true, the halting theorem is thus demonstrated


    *Proves that this is true*
    If simulating halt decider H correctly simulates its
    input D until [we can see] that its simulated D would
    never stop running unless aborted
    ^^^^^^^^^^^^^^
    HHH does abort DD, so DD is not a non-termating machine

    ur not gunna bust down the halting theorem for turing machines polcott,
    fine some other door to go down...

    while i agree with the sentiment there is something highly suspicious
    about the fact we can externally prove infinite recursion immediately
    based on witnessing a machine doing self-recursion (call itself) ... the
    algo does not work generally within machine and ur example proves it.
    the door i'm interested in is the ct-thesis

    the ct-thesis is not proven, so we don't need to refute any known
    proofs... we just need to show how we humans can compute some sequence
    that a machine cannot due to the halting theorem preventing it from doing so



    Bear in mind that in the above chain, only the outermost HHH counts as
    'simulating halt decider H' according to the Sipser criterion. HHH_1,
    HHH_2 and so on are not the halt decider. They are simply part of DD,
    the program under test. And if HHH_1 aborts its input, DD_1, that
    doesn't count as being aborted by the *halt decider*. HHH_1 is simply
    terminating according to its own rules.

    Your HHH decides it needs to abort DD, but that decision is incorrect
    since if HHH did *not* abort D, HHH_1 invoked inside DD would have
    eventually aborted DD_1, at which point control would be returned to
    DD which would then execute its return instruction.

    So HHH does not *correctly* determine that its input would not
    terminate unless aborted. It uses incorrect logic to prematurely abort
    DD.

    If your HHH did not include conditional code to abort its simulating,
    then you would have an infinitely recursive chain. But in that case
    the outermost HHH would never return a result so it wouldn't count as
    a halt decider.

    As it stands, your outermost HHH returns nonhalting for an input that
    *is* halting, so it also doesn't count as a halt decider.

    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 Dude@user2891@newsgrouper.org.invalid to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Tue Nov 3 18:03:34 2026
    From Newsgroup: sci.logic

    dart200 <user7160@newsgrouper.org.invalid> posted:

    On 11/3/26 8:47 AM, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:
    On 11/1/2026 8:09 PM, Mike Terry wrote:
    On 02/11/2026 00:36, Python wrote:
    You have STILL advanced exactly ZERO steps.

    You started with:

    -a-a-a simulated DD never reaches its final return state
    -a-a-a in any finite number of steps

    and now conclude:

    -a-a-a simulated DD never halts
    -a-a-a in any finite number of steps

    because "halting" means reaching a final state.

    Fine.

    THAT IS STILL THE SAME FUCKING PROPOSITION.

    Now comes the part you keep avoiding:

    How does HHH, which is supposed to be a HALT DECIDER, terminate and >>>>> return 0 to DD?

    If HHH(DD) never returns, then HHH is not a terminating halt
    decider on DD.

    If HHH(DD) returns 0, then DD executes:

    -a-a-a return Halt_Status;

    and halts.

    If HHH(DD) returns 1, DD loops.

    Those are the three cases.

    So your endless rewriting of:

    -a-a-a "DD does not reach its final state while HHH keeps simulating it"

    does not refute the Halting Theorem.

    It merely describes the case in which HHH DOES NOT RETURN.

    I'm not sure you're understanding the situation correctly...

    I mean, "DD does not reach its final state while HHH keeps
    simulating it" correctly describes the situation where HHH never
    aborts,

    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 }

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new
    instance of HHH (call it HHH_1). HHH_1 then simulates a new instance
    of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    true, the halting theorem is thus demonstrated

    Note to Nick:

    You must be new around here. These are supposed to be threaded
    messages, so people can follow along with the conversation.

    You're not supposed to be snipping your own thread and then cross
    posting to some messianic Buddhist board that hasn't seen nirvana
    since Ned passed away.

    So, what's your point?


    *Proves that this is true*
    If simulating halt decider H correctly simulates its
    input D until [we can see] that its simulated D would
    never stop running unless aborted
    ^^^^^^^^^^^^^^
    HHH does abort DD, so DD is not a non-termating machine

    ur not gunna bust down the halting theorem for turing machines polcott,
    fine some other door to go down...

    while i agree with the sentiment there is something highly suspicious
    about the fact we can externally prove infinite recursion immediately
    based on witnessing a machine doing self-recursion (call itself) ... the algo does not work generally within machine and ur example proves it.
    the door i'm interested in is the ct-thesis

    the ct-thesis is not proven, so we don't need to refute any known
    proofs... we just need to show how we humans can compute some sequence
    that a machine cannot due to the halting theorem preventing it from doing so



    Bear in mind that in the above chain, only the outermost HHH counts as
    'simulating halt decider H' according to the Sipser criterion. HHH_1,
    HHH_2 and so on are not the halt decider. They are simply part of DD,
    the program under test. And if HHH_1 aborts its input, DD_1, that
    doesn't count as being aborted by the *halt decider*. HHH_1 is simply
    terminating according to its own rules.

    Your HHH decides it needs to abort DD, but that decision is incorrect
    since if HHH did *not* abort D, HHH_1 invoked inside DD would have
    eventually aborted DD_1, at which point control would be returned to
    DD which would then execute its return instruction.

    So HHH does not *correctly* determine that its input would not
    terminate unless aborted. It uses incorrect logic to prematurely abort
    DD.

    If your HHH did not include conditional code to abort its simulating,
    then you would have an infinitely recursive chain. But in that case
    the outermost HHH would never return a result so it wouldn't count as
    a halt decider.

    As it stands, your outermost HHH returns nonhalting for an input that
    *is* halting, so it also doesn't count as a halt decider.

    Andr|-





    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic on Tue Nov 3 11:20:13 2026
    From Newsgroup: sci.logic

    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:
    On 11/1/2026 8:09 PM, Mike Terry wrote:
    On 02/11/2026 00:36, Python wrote:
    You have STILL advanced exactly ZERO steps.

    You started with:

    -a-a-a simulated DD never reaches its final return state
    -a-a-a in any finite number of steps

    and now conclude:

    -a-a-a simulated DD never halts
    -a-a-a in any finite number of steps

    because "halting" means reaching a final state.

    Fine.

    THAT IS STILL THE SAME FUCKING PROPOSITION.

    Now comes the part you keep avoiding:

    How does HHH, which is supposed to be a HALT DECIDER, terminate and >>>>> return 0 to DD?

    If HHH(DD) never returns, then HHH is not a terminating halt
    decider on DD.

    If HHH(DD) returns 0, then DD executes:

    -a-a-a return Halt_Status;

    and halts.

    If HHH(DD) returns 1, DD loops.

    Those are the three cases.

    So your endless rewriting of:

    -a-a-a "DD does not reach its final state while HHH keeps simulating it" >>>>>
    does not refute the Halting Theorem.

    It merely describes the case in which HHH DOES NOT RETURN.

    I'm not sure you're understanding the situation correctly...

    I mean, "DD does not reach its final state while HHH keeps
    simulating it" correctly describes the situation where HHH never
    aborts,

    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 }

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new
    instance of HHH (call it HHH_1). HHH_1 then simulates a new instance
    of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my point. DD *would* reach its own return call had it not been prematurely aborted by
    HHH. DD would reach its own return address because the HHH_1 called from within DD would eventually abort its input at which point HHH_1 would
    return control to DD which would then terminate normally.

    Andr|-

    *Proves that this is true*
    If simulating halt decider H correctly simulates its
    input D until [we can see] that its simulated D would
    never stop running unless aborted


    Bear in mind that in the above chain, only the outermost HHH counts as
    'simulating halt decider H' according to the Sipser criterion. HHH_1,
    HHH_2 and so on are not the halt decider. They are simply part of DD,
    the program under test. And if HHH_1 aborts its input, DD_1, that
    doesn't count as being aborted by the *halt decider*. HHH_1 is simply
    terminating according to its own rules.

    Your HHH decides it needs to abort DD, but that decision is incorrect
    since if HHH did *not* abort D, HHH_1 invoked inside DD would have
    eventually aborted DD_1, at which point control would be returned to
    DD which would then execute its return instruction.

    So HHH does not *correctly* determine that its input would not
    terminate unless aborted. It uses incorrect logic to prematurely abort
    DD.

    If your HHH did not include conditional code to abort its simulating,
    then you would have an infinitely recursive chain. But in that case
    the outermost HHH would never return a result so it wouldn't count as
    a halt decider.

    As it stands, your outermost HHH returns nonhalting for an input that
    *is* halting, so it also doesn't count as a halt decider.
    --
    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 on Tue Nov 3 13:03:34 2026
    From Newsgroup: sci.logic

    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:
    On 11/1/2026 8:09 PM, Mike Terry wrote:
    On 02/11/2026 00:36, Python wrote:
    You have STILL advanced exactly ZERO steps.

    You started with:

    -a-a-a simulated DD never reaches its final return state
    -a-a-a in any finite number of steps

    and now conclude:

    -a-a-a simulated DD never halts
    -a-a-a in any finite number of steps

    because "halting" means reaching a final state.

    Fine.

    THAT IS STILL THE SAME FUCKING PROPOSITION.

    Now comes the part you keep avoiding:

    How does HHH, which is supposed to be a HALT DECIDER, terminate
    and return 0 to DD?

    If HHH(DD) never returns, then HHH is not a terminating halt
    decider on DD.

    If HHH(DD) returns 0, then DD executes:

    -a-a-a return Halt_Status;

    and halts.

    If HHH(DD) returns 1, DD loops.

    Those are the three cases.

    So your endless rewriting of:

    -a-a-a "DD does not reach its final state while HHH keeps simulating it" >>>>>>
    does not refute the Halting Theorem.

    It merely describes the case in which HHH DOES NOT RETURN.

    I'm not sure you're understanding the situation correctly...

    I mean, "DD does not reach its final state while HHH keeps
    simulating it" correctly describes the situation where HHH never
    aborts,

    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 }

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new
    instance of HHH (call it HHH_1). HHH_1 then simulates a new instance
    of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my point. DD

    We already have a five-way consensus on the above words, quit cheating.

    *would* reach its own return call had it not been prematurely aborted by HHH. DD would reach its own return address because the HHH_1 called from within DD would eventually abort its input at which point HHH_1 would
    return control to DD which would then terminate normally.

    Andr|-

    *Proves that this is true*
    If simulating halt decider H correctly simulates its
    input D until [we can see] that its simulated D would
    never stop running unless aborted


    Bear in mind that in the above chain, only the outermost HHH counts
    as 'simulating halt decider H' according to the Sipser criterion.
    HHH_1, HHH_2 and so on are not the halt decider. They are simply part
    of DD, the program under test. And if HHH_1 aborts its input, DD_1,
    that doesn't count as being aborted by the *halt decider*. HHH_1 is
    simply terminating according to its own rules.

    Your HHH decides it needs to abort DD, but that decision is incorrect
    since if HHH did *not* abort D, HHH_1 invoked inside DD would have
    eventually aborted DD_1, at which point control would be returned to
    DD which would then execute its return instruction.

    So HHH does not *correctly* determine that its input would not
    terminate unless aborted. It uses incorrect logic to prematurely
    abort DD.

    If your HHH did not include conditional code to abort its simulating,
    then you would have an infinitely recursive chain. But in that case
    the outermost HHH would never return a result so it wouldn't count as
    a halt decider.

    As it stands, your outermost HHH returns nonhalting for an input that
    *is* halting, so it also doesn't count as a halt decider.


    --
    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 on Tue Nov 3 12:27:25 2026
    From Newsgroup: sci.logic

    On 2026-11-03 12:03, olcott wrote:
    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new
    instance of HHH (call it HHH_1). HHH_1 then simulates a new instance
    of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my point. DD

    We already have a five-way consensus on the above words, quit cheating.

    There appears to be a disconnect between what others have agreed to and
    what you *think* they have agreed to. Python has pointed this out to you numerous times.

    Pointing out a flaw in your reasoning hardly constitutes 'cheating'.
    Maybe actually address the point.

    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 on Tue Nov 3 13:50:06 2026
    From Newsgroup: sci.logic

    On 11/3/2026 1:27 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:03, olcott wrote:
    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new
    instance of HHH (call it HHH_1). HHH_1 then simulates a new
    instance of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my point. DD

    We already have a five-way consensus on the above words, quit cheating.

    There appears to be a disconnect between what others have agreed to and
    what you *think* they have agreed to. Python has pointed this out to you numerous times.


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


    Pointing out a flaw in your reasoning hardly constitutes 'cheating'.
    Maybe actually address the point.

    Andr|-



    There never has been a flaw in that reasoning.
    dbush helped write the prior version.
    --
    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,alt.messianic,alt.buddha.short.fat.guy on Tue Nov 3 13:32:39 2026
    From Newsgroup: sci.logic

    On 11/2/2026 11:43 PM, dart200 wrote:
    On 11/2/26 9:24 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later: >>>>>>>>>>>>>>>>>>
    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts >>>>>>>>>>>>>>>>>

    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the >>>>>>>>>>>>>>> halting semantics of DD when simulated by universal >>>>>>>>>>>>>>> simulator (EYon as defined by turing), which is the halting >>>>>>>>>>>>>>> semantics we are interested in:

    <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 >>>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted >>>>>>>>>>>>

    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which >>>>>>>> the conclusion rests upon a statement made by some presumed
    authority or witness... Because the testimony of a qualified
    authority or witness provides a reason for believing a claim, >>>>>>>> such arguments are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D >>>>>>> would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted then* >>>

    That is a completely dishonest paraphrase.
    I spent two years coming up with those words
    knowing his phone number the whole time. I
    did not call until I got them right.

    ur actively ignoring the conditional on the proof, which is that H is
    correct if and only if D is then not aborted...


    its simulated DD would never HALT unless stops being simulated

    yes DD _would_ never HALT _unless_ HHH aborts it

    _would_ implies a hypothetical based on a conditional, in this case that
    HHH does _not_ abort it

    HHH however does abort DD, violating the required condition (that HHH
    does _not_ abort it) for HHH to truthfully prove that DD is a non- terminating machine

    Pretty much.



    HHH aborts DD's simulation, so therefore the analysis HHH makes prior
    to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going
    to try to post helpful comments polcott. and i suggest that ignoring
    the conditional is a major flaw in what ur trying to propose atm




    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Python@python@cccp.invalid to comp.theory,sci.logic on Tue Nov 3 22:12:23 2026
    From Newsgroup: sci.logic

    Peter,

    FOR FUCK'S SAKE. YOU ARE DOING IT AGAIN.

    Andr|- writes:

    "There appears to be a disconnect between what others
    have agreed to and what you *think* they have agreed to.
    Python has pointed this out to you numerous times."

    And what do you do?

    YOU QUOTE ME AGAIN.

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

    Yes, Peter. THOSE ARE MY WORDS.

    And I have told you, repeatedly, explicitly, and in capital letters, that
    my agreement is LIMITED TO THAT STATEMENT.

    It does NOT establish that HHH correctly determines non-halting.

    It does NOT establish your claimed equivalence with "WOULD NEVER HALT
    UNLESS ABORTED".

    It does NOT establish Sipser's premise.

    And it most certainly does NOT refute the Halting Theorem.

    Yet you keep reproducing my quotation whenever someone challenges your reasoning, as though my agreement were evidence in your favor.

    IT IS NOT.

    And now:

    "dbush helped write the prior version."

    SO FUCKING WHAT?

    Helping formulate a proposition does not constitute agreement with every conclusion YOU subsequently claim follows from it.

    You have been explicitly warned about this distinction, by me and now by Andr|-.

    Your "five-way consensus" is a consensus on a LIMITED PROPOSITION, not on
    your purported proof.

    STOP USING MY NAME AND MY WORDS TO SUGGEST OTHERWISE.

    Andr|- has identified a problem in your reasoning.

    ANSWER HIM.

    Repeating a proposition that other people agreed to is not an answer to an objection about what you claim follows from it.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Tue Nov 3 16:26:14 2026
    From Newsgroup: sci.logic

    On 11/3/2026 4:12 PM, Python wrote:
    Peter,

    FOR FUCK'S SAKE. YOU ARE DOING IT AGAIN.

    Andr|- writes:

    -a-a "There appears to be a disconnect between what others
    -a-a-a have agreed to and what you *think* they have agreed to.
    -a-a-a Python has pointed this out to you numerous times."

    And what do you do?

    YOU QUOTE ME AGAIN.

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

    Yes, Peter. THOSE ARE MY WORDS.

    And I have told you, repeatedly, explicitly, and in capital letters,
    that my agreement is LIMITED TO THAT STATEMENT.


    Likewise I said that is fine.

    I think that you also agreed with this version the dbush
    helped 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.

    It does NOT establish that HHH correctly determines non-halting.


    That you do not understand that your own words
    prove that DD simulated by HHH does not halt is
    a lack of understanding on your part.

    That you don't understand that yet is OK.

    It does NOT establish your claimed equivalence with "WOULD NEVER HALT
    UNLESS ABORTED".

    It does NOT establish Sipser's premise.


    *You own words proves that this is true*
    If simulating halt decider H correctly simulates its
    input D until [we can see] that its simulated D would
    never stop running unless aborted.

    That you don't understand that yet is OK.

    And it most certainly does NOT refute the Halting Theorem.

    Yet you keep reproducing my quotation whenever someone challenges your reasoning, as though my agreement were evidence in your favor.

    IT IS NOT.

    And now:

    -a-a "dbush helped write the prior version."

    SO FUCKING WHAT?

    Helping formulate a proposition does not constitute agreement with every conclusion YOU subsequently claim follows from it.


    *It does mean 100% complete agreement with this one*
    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.

    You have been explicitly warned about this distinction, by me and now by Andr|-.

    Your "five-way consensus" is a consensus on a LIMITED PROPOSITION, not
    on your purported proof.


    Of course. I have never said otherwise.

    STOP USING MY NAME AND MY WORDS TO SUGGEST OTHERWISE.

    Andr|- has identified a problem in your reasoning.

    ANSWER HIM.


    He has indicated that he thinks he can keep getting
    away with rebutting the five-way consensus.

    Repeating a proposition that other people agreed to is not an answer to
    an objection about what you claim follows from it.

    That is why name/time/date stamped verbatim quotes are best.
    --
    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@python@cccp.invalid to comp.theory,sci.logic on Tue Nov 3 22:33:54 2026
    From Newsgroup: sci.logic

    You write:

    "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone
    challenges YOUR conclusions.

    And in this very message, you accuse Andr|- of:

    "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition.

    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist.

    And this:

    "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not establish your claimed semantic conclusion, the correctness of HHH's decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    "H correctly determines"

    with:

    "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the inference
    establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square brackets.

    And please spare me:

    "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension.

    Now, Peter, you have repeatedly and publicly presented yourself as a Christian.

    Perhaps you should seriously reflect on what that entails for your own conduct.

    Honesty matters. So does humility. So does representing other people's
    words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to correct
    your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I have
    explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too.

    Perhaps it's time to apply some of those Christian principles you profess
    to yourself, rather than lecturing everyone else about their supposed inability to understand you.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Tue Nov 3 16:40:49 2026
    From Newsgroup: sci.logic

    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone
    challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anything
    like 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.


    And in this very message, you accuse Andr|- of:

    -a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition.

    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist.

    And this:

    -a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not establish your claimed semantic conclusion, the correctness of HHH's decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a "H correctly determines"

    with:

    -a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the inference establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square brackets.

    And please spare me:

    -a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension.

    Now, Peter, you have repeatedly and publicly presented yourself as a Christian.

    Perhaps you should seriously reflect on what that entails for your own conduct.

    Honesty matters. So does humility. So does representing other people's
    words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to correct
    your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support for
    your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too.

    Perhaps it's time to apply some of those Christian principles you
    profess to yourself, rather than lecturing everyone else about their supposed inability to understand you.
    --
    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@python@cccp.invalid to comp.theory,sci.logic on Tue Nov 3 22:50:39 2026
    From Newsgroup: sci.logic

    WHAT THE FUCK DOES THAT HAVE TO DO WITH WHAT I JUST TOLD YOU?

    I accuse you of repeatedly misrepresenting the scope of other people's agreement.

    And your answer is:

    "You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has ever agreed with anything
    like this until last Sunday."

    SO WHAT?

    Whether you waited twenty-two years, twenty-two minutes, or twenty-two centuries for someone to agree with that proposition is COMPLETELY
    IRRELEVANT.

    You have obtained agreement on ONE LIMITED STATEMENT.

    Congratulations.

    Nobody is trying to take that agreement away from you.

    What we are challenging is what YOU CLAIM FOLLOWS FROM IT.

    And THAT is precisely what you keep refusing to address.

    Instead, you repeatedly invoke the names of people who agreed with the
    limited statement, as though their agreement somehow strengthened your subsequent conclusions.

    It doesn't.

    You have turned a mathematical discussion into a story about your
    twenty-two years of struggle and your long-awaited recognition.

    But mathematics does not work that way.

    A proposition does not become more powerful because nobody agreed with it
    for twenty-two years.

    An invalid inference does not become valid because five people agree with
    its premise.

    And an objection to YOUR inference is not an objection to THEIR agreement.

    Most importantly, you have STILL not answered my accusation:

    WHY DO YOU KEEP INVOKING MY AGREEMENT TO SUPPORT CONCLUSIONS THAT I HAVE EXPLICITLY REJECTED?

    Stop telling us how long you waited for agreement.

    Stop telling us how many people agreed.

    Stop telling us who helped formulate the statement.

    NONE OF THAT PROVES YOUR NEXT STEP.

    And none of it excuses your repeated misrepresentation of what other
    people actually agreed to.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Tue Nov 3 16:55:13 2026
    From Newsgroup: sci.logic

    On 11/3/2026 4:50 PM, Python wrote:
    WHAT THE FUCK DOES THAT HAVE TO DO WITH WHAT I JUST TOLD YOU?

    I accuse you of repeatedly misrepresenting the scope of other people's agreement.

    And your answer is:

    -a-a "You can look at the record on news.giganews.com
    -a-a-a where my posts go back to 2004 and see that no
    -a-a-a one from comp.theory has ever agreed with anything
    -a-a-a like this until last Sunday."

    SO WHAT?

    Whether you waited twenty-two years, twenty-two minutes, or twenty-two centuries for someone to agree with that proposition is COMPLETELY IRRELEVANT.


    It is completely relevant. You don't care
    to see how and why is it completely relevant.
    Come back when you care about the truth
    enormously more than you care about rebuttal.

    You have obtained agreement on ONE LIMITED STATEMENT.

    Congratulations.

    Nobody is trying to take that agreement away from you.

    What we are challenging is what YOU CLAIM FOLLOWS FROM IT.

    And THAT is precisely what you keep refusing to address.

    Instead, you repeatedly invoke the names of people who agreed with the limited statement, as though their agreement somehow strengthened your subsequent conclusions.

    It doesn't.

    You have turned a mathematical discussion into a story about your
    twenty-two years of struggle and your long-awaited recognition.

    But mathematics does not work that way.

    A proposition does not become more powerful because nobody agreed with
    it for twenty-two years.

    An invalid inference does not become valid because five people agree
    with its premise.

    And an objection to YOUR inference is not an objection to THEIR agreement.

    Most importantly, you have STILL not answered my accusation:

    WHY DO YOU KEEP INVOKING MY AGREEMENT TO SUPPORT CONCLUSIONS THAT I HAVE EXPLICITLY REJECTED?

    Stop telling us how long you waited for agreement.

    Stop telling us how many people agreed.

    Stop telling us who helped formulate the statement.

    NONE OF THAT PROVES YOUR NEXT STEP.

    And none of it excuses your repeated misrepresentation of what other
    people actually agreed to.
    --
    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 on Tue Nov 3 14:56:40 2026
    From Newsgroup: sci.logic

    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone
    challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH cannot accurately decide on DD Efn+

    this doesn't stop EYon(DD) from being a halting machine or from HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition.

    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not establish
    your claimed semantic conclusion, the correctness of HHH's decision,
    or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the inference
    establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension.

    Now, Peter, you have repeatedly and publicly presented yourself as a
    Christian.

    Perhaps you should seriously reflect on what that entails for your own
    conduct.

    Honesty matters. So does humility. So does representing other people's
    words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to
    correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support for
    your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I have
    explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too.

    Perhaps it's time to apply some of those Christian principles you
    profess to yourself, rather than lecturing everyone else about their
    supposed inability to understand 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 on Tue Nov 3 16:59:48 2026
    From Newsgroup: sci.logic

    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone
    challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    this doesn't stop EYon(DD) from being a halting machine or from HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition.

    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not establish
    your claimed semantic conclusion, the correctness of HHH's decision,
    or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the inference
    establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension.

    Now, Peter, you have repeatedly and publicly presented yourself as a
    Christian.

    Perhaps you should seriously reflect on what that entails for your
    own conduct.

    Honesty matters. So does humility. So does representing other
    people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to
    correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support for
    your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I have
    explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too.

    Perhaps it's time to apply some of those Christian principles you
    profess to yourself, rather than lecturing everyone else about their
    supposed inability to understand you.




    --
    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 on Tue Nov 3 16:13:21 2026
    From Newsgroup: sci.logic

    On 2026-11-03 12:50, olcott wrote:
    On 11/3/2026 1:27 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:03, olcott wrote:
    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new
    instance of HHH (call it HHH_1). HHH_1 then simulates a new
    instance of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my point. DD >>>
    We already have a five-way consensus on the above words, quit cheating.

    There appears to be a disconnect between what others have agreed to
    and what you *think* they have agreed to. Python has pointed this out
    to you numerous times.


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

    Yes. *While* the simulation continues, DD does not reach its return instruction. That's because your HHH stops simulating (aborts) before DD reaches its return instruction; not because DD wouldn't ultimately reach
    its return instruction had the simulation continued just a wee bit longer.


    Pointing out a flaw in your reasoning hardly constitutes 'cheating'.
    Maybe actually address the point.

    Andr|-



    There never has been a flaw in that reasoning.
    dbush helped write the prior version.

    Your HHH claims that DD, a halting program, doesn't halt. I'd call that
    a major flaw in HHH's logic.

    The problem is that you claim to have identified a 'non-halting pattern'
    where no such pattern exists.

    You claim that when a function is called twice from the same address
    with no intervening conditional statements, it constitutes a non halting pattern. But there *are* conditional statements intervening which your
    HHH simply ignores. The HHH_1 which is invoked from within your DD, *conditionally* simulates DD_1. After each step in the simulation it
    checks for your 'non-halting pattern' and only continues to simulate if
    that pattern isn't met. Why does HHH not count those conditional
    statements as conditional statements?

    And Python has already called into question the accuracy of your alleged pattern but you've simply ignored him.

    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 on Tue Nov 3 17:19:31 2026
    From Newsgroup: sci.logic

    On 11/3/2026 5:13 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:50, olcott wrote:
    On 11/3/2026 1:27 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:03, olcott wrote:
    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new >>>>>>> instance of HHH (call it HHH_1). HHH_1 then simulates a new
    instance of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my
    point. DD

    We already have a five-way consensus on the above words, quit cheating. >>>
    There appears to be a disconnect between what others have agreed to
    and what you *think* they have agreed to. Python has pointed this out
    to you numerous times.


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

    Yes. *While* the simulation continues, DD does not reach its return

    This *is* the correct non-halting criteria that
    specifies the halt property of the finite string
    input.

    What HHH does after this non-halt criteria has been
    met has no effect on whether this non-halting criteria
    has been met.

    instruction. That's because your HHH stops simulating (aborts) before DD reaches its return instruction; not because DD wouldn't ultimately reach
    its return instruction had the simulation continued just a wee bit longer.


    Pointing out a flaw in your reasoning hardly constitutes 'cheating'.
    Maybe actually address the point.

    Andr|-



    There never has been a flaw in that reasoning.
    dbush helped write the prior version.

    Your HHH claims that DD, a halting program, doesn't halt. I'd call that
    a major flaw in HHH's logic.

    The problem is that you claim to have identified a 'non-halting pattern' where no such pattern exists.

    You claim that when a function is called twice from the same address
    with no intervening conditional statements, it constitutes a non halting pattern. But there *are* conditional statements intervening which your
    HHH simply ignores. The HHH_1 which is invoked from within your DD, *conditionally* simulates DD_1. After each step in the simulation it
    checks for your 'non-halting pattern' and only continues to simulate if
    that pattern isn't met. Why does HHH not count those conditional
    statements as conditional statements?

    And Python has already called into question the accuracy of your alleged pattern but you've simply ignored him.

    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 on Tue Nov 3 15:32:18 2026
    From Newsgroup: sci.logic

    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone
    challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH cannot
    accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott

    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from HHH1
    recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition.

    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not establish
    your claimed semantic conclusion, the correctness of HHH's decision,
    or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the inference
    establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension.

    Now, Peter, you have repeatedly and publicly presented yourself as a
    Christian.

    Perhaps you should seriously reflect on what that entails for your
    own conduct.

    Honesty matters. So does humility. So does representing other
    people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to
    correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support for
    your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I have
    explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too.

    Perhaps it's time to apply some of those Christian principles you
    profess to yourself, rather than lecturing everyone else about their
    supposed inability to understand 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 on Tue Nov 3 17:36:30 2026
    From Newsgroup: sci.logic

    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone
    challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH cannot
    accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from HHH1
    recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition.

    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not establish
    your claimed semantic conclusion, the correctness of HHH's
    decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the inference
    establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square brackets. >>>>>
    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension.

    Now, Peter, you have repeatedly and publicly presented yourself as
    a Christian.

    Perhaps you should seriously reflect on what that entails for your
    own conduct.

    Honesty matters. So does humility. So does representing other
    people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to
    correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support
    for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I have >>>>> explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too.

    Perhaps it's time to apply some of those Christian principles you
    profess to yourself, rather than lecturing everyone else about
    their supposed inability to understand you.








    --
    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 on Tue Nov 3 17:22:47 2026
    From Newsgroup: sci.logic

    On 2026-11-03 16:19, olcott wrote:
    On 11/3/2026 5:13 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:50, olcott wrote:
    On 11/3/2026 1:27 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:03, olcott wrote:
    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new >>>>>>>> instance of HHH (call it HHH_1). HHH_1 then simulates a new
    instance of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my
    point. DD

    We already have a five-way consensus on the above words, quit
    cheating.

    There appears to be a disconnect between what others have agreed to
    and what you *think* they have agreed to. Python has pointed this
    out to you numerous times.


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

    Yes. *While* the simulation continues, DD does not reach its return

    This *is* the correct non-halting criteria that
    specifies the halt property of the finite string
    input.

    If it gives the wrong answer it is decidedly *not* a correct criterion.
    And it does give the wrong answer. I even pointed out the specific bug
    in your code which leads it to that wrong answer.

    And all your nonsense about 'finite sting inputs' is simply subterfuge.
    Finite strings are not halting or non-halting. The programs which they represent may be halting or non-halting. This is just your ludicrous
    attempt to somehow claim that HHH simulates DD differently than when DD
    is run directly, and yet is still somehow a correct simulation. This is
    prima facie absurd.

    What HHH does after this non-halt criteria has been
    met has no effect on whether this non-halting criteria
    has been met.

    What matters is what DD would have done if it's simulation had continued
    past the point when HHH decided to discontinue it.

    Remember that if your example had actually followed Linz's proof, DDD
    wouldn't call HHH; it would contain it's own private copy of HHH (call
    it HHH_1). If you had set things up this way you could easily verify my
    claims by simply removing the abort code from HHH while leaving the
    abort code in HHH_1 intact. In such a case, your HHH would return
    *halting* for DD, exactly as it should.

    Andr|-

    instruction. That's because your HHH stops simulating (aborts) before
    DD reaches its return instruction; not because DD wouldn't ultimately
    reach its return instruction had the simulation continued just a wee
    bit longer.
    --
    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 on Tue Nov 3 18:28:38 2026
    From Newsgroup: sci.logic

    On 11/3/2026 6:22 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 16:19, olcott wrote:
    On 11/3/2026 5:13 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:50, olcott wrote:
    On 11/3/2026 1:27 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:03, olcott wrote:
    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a >>>>>>>>> new instance of HHH (call it HHH_1). HHH_1 then simulates a new >>>>>>>>> instance of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my
    point. DD

    We already have a five-way consensus on the above words, quit
    cheating.

    There appears to be a disconnect between what others have agreed to >>>>> and what you *think* they have agreed to. Python has pointed this
    out to you numerous times.


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

    Yes. *While* the simulation continues, DD does not reach its return

    This *is* the correct non-halting criteria that
    specifies the halt property of the finite string
    input.

    If it gives the wrong answer it is decidedly *not* a correct criterion.

    You dishonestly change the question. Are you a liar?

    five-way consensus that took five years because
    everyone persistently lied:

    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.

    I am going to assume that you are a liar unless you
    prove otherwise in your next reply.

    And it does give the wrong answer. I even pointed out the specific bug
    in your code which leads it to that wrong answer.

    And all your nonsense about 'finite sting inputs' is simply subterfuge. Finite strings are not halting or non-halting. The programs which they represent may be halting or non-halting. This is just your ludicrous
    attempt to somehow claim that HHH simulates DD differently than when DD
    is run directly, and yet is still somehow a correct simulation. This is prima facie absurd.

    What HHH does after this non-halt criteria has been
    met has no effect on whether this non-halting criteria
    has been met.

    What matters is what DD would have done if it's simulation had continued past the point when HHH decided to discontinue it.

    Remember that if your example had actually followed Linz's proof, DDD wouldn't call HHH; it would contain it's own private copy of HHH (call
    it HHH_1). If you had set things up this way you could easily verify my claims by simply removing the abort code from HHH while leaving the
    abort code in HHH_1 intact. In such a case, your HHH would return
    *halting* for DD, exactly as it should.

    Andr|-

    instruction. That's because your HHH stops simulating (aborts) before
    DD reaches its return instruction; not because DD wouldn't ultimately
    reach its return instruction had the simulation continued just a wee
    bit longer.

    --
    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@python@cccp.invalid to comp.theory,sci.logic on Wed Nov 4 00:35:52 2026
    From Newsgroup: sci.logic

    YOU HAVE SOME FUCKING NERVE CALLING ANDR|e A LIAR.

    Andr|- has just given you a SPECIFIC, TECHNICAL, TESTABLE objection to
    your implementation.

    He distinguishes:

    HHH : the outer simulator

    HHH_1 : the copy of HHH invoked by simulated DD

    He proposes removing the abort mechanism from the outer HHH while
    retaining it in HHH_1, and predicts that the outer simulator will then
    observe DD halting.

    That is a concrete technical claim. It can be examined, tested, and either confirmed or refuted.

    And your response?

    "Are you a liar?"

    "everyone persistently lied"

    "I am going to assume that you are a liar unless
    you prove otherwise in your next reply."

    WHAT THE FUCK IS WRONG WITH YOUR APPROACH TO MATHEMATICAL DISCUSSION?

    Someone identifies a potential bug in your code and explains how to expose
    it.

    You don't examine the proposed test.

    You don't demonstrate why it would fail.

    You don't identify a flaw in the reasoning.

    Instead, you accuse him of dishonesty and repeat your precious "five-way consensus".

    AGAIN.

    Andr|- is NOT disputing that limited proposition.

    He is disputing the correctness of the non-halting conclusion you claim to derive from it.

    YOU KNOW THE DIFFERENCE.

    I have explained it to you repeatedly.

    You have explicitly acknowledged it.

    And yet you keep treating criticism of your inference as an attack on the agreement itself.

    That is not a misunderstanding anymore. It is a persistent
    misrepresentation of the discussion.

    And here is the particularly grotesque part:

    You demand that Andr|- prove he is not a liar, while YOU repeatedly
    attribute to other people conclusions they have explicitly rejected.

    You have been corrected about this, publicly, repeatedly, and in
    unmistakable language.

    Perhaps you should examine your OWN conduct before accusing everyone else
    of dishonesty.

    You claim to have spent twenty-two years pursuing mathematical truth.

    Then start behaving like someone interested in truth.

    ANSWER ANDR|e'S TECHNICAL OBJECTION.

    Explain why his proposed distinction between HHH and HHH_1 is invalid, or
    why his predicted execution would not occur.

    Show the code. Show the execution trace. Show the precise error, if there
    is one.

    And STOP hiding behind the names of people who agreed with a limited proposition.

    Their agreement does not validate your detector.

    Their agreement does not establish Sipser's premise.

    Their agreement does not refute the Halting Theorem.

    And their agreement certainly does not entitle you to call your critics
    liars.

    At this point, Peter, the person whose intellectual honesty is most
    urgently in need of examination is YOU.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Tue Nov 3 18:45:51 2026
    From Newsgroup: sci.logic

    On 11/3/2026 6:35 PM, Python wrote:
    YOU HAVE SOME FUCKING NERVE CALLING ANDR|e A LIAR.

    Andr|- has just given you a SPECIFIC, TECHNICAL, TESTABLE objection to
    your implementation.

    He distinguishes:

    -a-a HHH-a-a : the outer simulator


    The outer executable process has always been
    assumed as exactly one-and-the-same thing as
    the finite string input to HHH even though
    everyone knows this is a lie.

    They take equivalent as one-and-the-same
    exact same thing.

    2 + 3 = 2 + 3 are one-and-the-same exact same thing.
    2 + 3 = 5 ARE NOT one-and-the-same exact same thing.


    -a-a HHH_1 : the copy of HHH invoked by simulated DD

    He proposes removing the abort mechanism from the outer HHH while
    retaining it in HHH_1, and predicts that the outer simulator will then observe DD halting.

    That is a concrete technical claim. It can be examined, tested, and
    either confirmed or refuted.

    And your response?

    -a-a "Are you a liar?"

    -a-a "everyone persistently lied"

    -a-a "I am going to assume that you are a liar unless
    -a-a-a you prove otherwise in your next reply."

    WHAT THE FUCK IS WRONG WITH YOUR APPROACH TO MATHEMATICAL DISCUSSION?

    Someone identifies a potential bug in your code and explains how to
    expose it.

    You don't examine the proposed test.

    You don't demonstrate why it would fail.

    You don't identify a flaw in the reasoning.

    Instead, you accuse him of dishonesty and repeat your precious "five-way consensus".

    AGAIN.

    Andr|- is NOT disputing that limited proposition.

    He is disputing the correctness of the non-halting conclusion you claim
    to derive from it.

    YOU KNOW THE DIFFERENCE.

    I have explained it to you repeatedly.

    You have explicitly acknowledged it.

    And yet you keep treating criticism of your inference as an attack on
    the agreement itself.

    That is not a misunderstanding anymore. It is a persistent
    misrepresentation of the discussion.

    And here is the particularly grotesque part:

    You demand that Andr|- prove he is not a liar, while YOU repeatedly attribute to other people conclusions they have explicitly rejected.

    You have been corrected about this, publicly, repeatedly, and in unmistakable language.

    Perhaps you should examine your OWN conduct before accusing everyone
    else of dishonesty.

    You claim to have spent twenty-two years pursuing mathematical truth.

    Then start behaving like someone interested in truth.

    ANSWER ANDR|e'S TECHNICAL OBJECTION.

    Explain why his proposed distinction between HHH and HHH_1 is invalid,
    or why his predicted execution would not occur.

    Show the code. Show the execution trace. Show the precise error, if
    there is one.

    And STOP hiding behind the names of people who agreed with a limited proposition.

    Their agreement does not validate your detector.

    Their agreement does not establish Sipser's premise.

    Their agreement does not refute the Halting Theorem.

    And their agreement certainly does not entitle you to call your critics liars.

    At this point, Peter, the person whose intellectual honesty is most
    urgently in need of examination is YOU.
    --
    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@python@cccp.invalid to comp.theory,sci.logic on Wed Nov 4 00:52:39 2026
    From Newsgroup: sci.logic

    Peter,

    WHAT THE FUCK ARE YOU TALKING ABOUT?

    Andr|-'s objection is precisely about DISTINGUISHING two execution
    instances.

    HHH : the outer simulator

    HHH_1 : the instance invoked by simulated DD

    NOBODY IS CLAIMING THEY ARE THE SAME EXECUTION INSTANCE.

    THAT IS THE FUCKING POINT.

    Andr|- proposes a concrete experiment involving these two distinct
    instances.

    You respond with:

    2 + 3 = 2 + 3

    2 + 3 = 5

    and a lecture about identity versus equivalence.

    HOW DOES ANY OF THAT ANSWER HIS OBJECTION?

    It doesn't.

    Two syntactically different expressions can have the same value. Two executions of the same code can have different states and different
    outcomes.

    But none of that establishes that your non-halting detector is correct.

    You have simply changed the subject AGAIN.

    And you have STILL not answered the actual question:

    If the outer HHH continues simulating while the nested HHH_1 retains its
    abort mechanism, what exactly happens?

    Does simulated DD eventually return?

    If not, identify the precise execution step that prevents it.

    If yes, explain why your original outer HHH reported non-halting.

    THAT IS THE TEST.

    Not whether 2 + 3 is syntactically identical to 5.

    Not whether two processes are "one-and-the-same exact same thing."

    Not whether your critics have been lying for twenty-two years.

    THE FUCKING EXECUTION TRACE.

    You have spent years demanding that everybody pay attention to every
    subtle detail of your implementation.

    Well, here is your opportunity.

    SHOW US THE DETAILS.

    Or admit that you have no technical answer to Andr|-'s objection.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Tue Nov 3 18:59:34 2026
    From Newsgroup: sci.logic

    On 11/3/2026 6:52 PM, Python wrote:
    Peter,

    WHAT THE FUCK ARE YOU TALKING ABOUT?

    Andr|-'s objection is precisely about DISTINGUISHING two execution instances.


    That was always the mistake of how the foundations
    of computation has been applied to the halting theorem.
    There is only one of those two that meets this requirement.

    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 strings is outside of the domain of
    ChurchrCoTuring computable functions.


    -a-a HHH-a-a : the outer simulator

    -a-a HHH_1 : the instance invoked by simulated DD

    NOBODY IS CLAIMING THEY ARE THE SAME EXECUTION INSTANCE.

    THAT IS THE FUCKING POINT.

    Andr|- proposes a concrete experiment involving these two distinct instances.

    You respond with:

    -a-a 2 + 3 = 2 + 3

    -a-a 2 + 3 = 5

    and a lecture about identity versus equivalence.

    HOW DOES ANY OF THAT ANSWER HIS OBJECTION?

    It doesn't.

    Two syntactically different expressions can have the same value. Two executions of the same code can have different states and different outcomes.

    But none of that establishes that your non-halting detector is correct.

    You have simply changed the subject AGAIN.

    And you have STILL not answered the actual question:

    If the outer HHH continues simulating while the nested HHH_1 retains its abort mechanism, what exactly happens?

    Does simulated DD eventually return?

    If not, identify the precise execution step that prevents it.

    If yes, explain why your original outer HHH reported non-halting.

    THAT IS THE TEST.

    Not whether 2 + 3 is syntactically identical to 5.

    Not whether two processes are "one-and-the-same exact same thing."

    Not whether your critics have been lying for twenty-two years.

    THE FUCKING EXECUTION TRACE.

    You have spent years demanding that everybody pay attention to every
    subtle detail of your implementation.

    Well, here is your opportunity.

    SHOW US THE DETAILS.

    Or admit that you have no technical answer to Andr|-'s objection.
    --
    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 on Tue Nov 3 18:36:55 2026
    From Newsgroup: sci.logic

    On 2026-11-03 17:28, olcott wrote:
    On 11/3/2026 6:22 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 16:19, olcott wrote:
    On 11/3/2026 5:13 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:50, olcott wrote:
    On 11/3/2026 1:27 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:03, olcott wrote:
    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a >>>>>>>>>> new instance of HHH (call it HHH_1). HHH_1 then simulates a >>>>>>>>>> new instance of DD_1, which in turn calls HHH_2 and so forth. >>>>>>>>>>
    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my >>>>>>>> point. DD

    We already have a five-way consensus on the above words, quit
    cheating.

    There appears to be a disconnect between what others have agreed
    to and what you *think* they have agreed to. Python has pointed
    this out to you numerous times.


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

    Yes. *While* the simulation continues, DD does not reach its return

    This *is* the correct non-halting criteria that
    specifies the halt property of the finite string
    input.

    If it gives the wrong answer it is decidedly *not* a correct criterion.

    You dishonestly change the question. Are you a liar?

    Which question do you claim I changed? Instead of accusing me of lying,
    why not address the actual points which I made?

    Andr|-

    five-way consensus that took five years because
    everyone persistently lied:

    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.

    I am going to assume that you are a liar unless you
    prove otherwise in your next reply.

    And it does give the wrong answer. I even pointed out the specific bug
    in your code which leads it to that wrong answer.

    And all your nonsense about 'finite sting inputs' is simply
    subterfuge. Finite strings are not halting or non-halting. The
    programs which they represent may be halting or non-halting. This is
    just your ludicrous attempt to somehow claim that HHH simulates DD
    differently than when DD is run directly, and yet is still somehow a
    correct simulation. This is prima facie absurd.

    What HHH does after this non-halt criteria has been
    met has no effect on whether this non-halting criteria
    has been met.

    What matters is what DD would have done if it's simulation had
    continued past the point when HHH decided to discontinue it.

    Remember that if your example had actually followed Linz's proof, DDD
    wouldn't call HHH; it would contain it's own private copy of HHH (call
    it HHH_1). If you had set things up this way you could easily verify
    my claims by simply removing the abort code from HHH while leaving the
    abort code in HHH_1 intact. In such a case, your HHH would return
    *halting* for DD, exactly as it should.

    Andr|-

    instruction. That's because your HHH stops simulating (aborts)
    before DD reaches its return instruction; not because DD wouldn't
    ultimately reach its return instruction had the simulation continued
    just a wee bit longer.



    --
    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 on Tue Nov 3 19:47:58 2026
    From Newsgroup: sci.logic

    On 11/3/2026 5:13 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:50, olcott wrote:
    On 11/3/2026 1:27 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:03, olcott wrote:
    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new >>>>>>> instance of HHH (call it HHH_1). HHH_1 then simulates a new
    instance of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my
    point. DD

    We already have a five-way consensus on the above words, quit cheating. >>>
    There appears to be a disconnect between what others have agreed to
    and what you *think* they have agreed to. Python has pointed this out
    to you numerous times.


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

    Yes. *While* the simulation continues, DD does not reach its return instruction.


    That's because your HHH stops simulating (aborts) before DD
    reaches its return instruction;

    *A five-way consensus disagrees*
    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.

    *Thus you are a liar at this point*

    If you become the 6th of this five-way
    consensus I will start talking to you again.
    --
    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 on Tue Nov 3 18:51:56 2026
    From Newsgroup: sci.logic

    On 2026-11-03 17:59, olcott wrote:
    On 11/3/2026 6:52 PM, Python wrote:
    Peter,

    WHAT THE FUCK ARE YOU TALKING ABOUT?

    Andr|-'s objection is precisely about DISTINGUISHING two execution
    instances.


    That was always the mistake of how the foundations
    of computation has been applied to the halting theorem.
    There is only one of those two that meets this requirement.

    So which one are you claiming fails to meet your requirements?

    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 strings is outside of the domain of
    ChurchrCoTuring computable functions.

    You make this claim, but you then read all kinds of stuff into it which
    simply isn't true. You keep talking about mistakes in the foundations of computation, but you consistently demonstrate that you don't understand
    those foundation.

    Post proposes a model of computation involving string transformations,
    and Turing's work can be considered to say the same thing.

    It does *not* follow from the fact that computations can be modelled
    using strings that all computations are fundamentally about strings.
    They are not. Strings are used to represent things that we want
    computations to deal with.

    A week or two ago I gave you a trivial example: Consider a TM which
    decides whether a given natural number is prime. You give that TM the
    input '10'. '10' is a string. It makes no sense to ask whether this
    string is prime since strings don't have the property of primeness. Computations about strings can ask questions like 'what is the length of
    this string?' (2 symbols) or 'is this string a palindrome' (no), but to
    ask whether '10' is prime is meaningless.

    We made feed the string '10' into a prime decider, but the decider is
    being asked about the natural number which that string represents. And
    that single string can represent a variety of different natural numbers depending on what encoding our TM is using. As soon as we start talking
    about encodings, we are talking about how we *represent* things using
    strings.

    '10' (in quotes) could represent the number 10 (note the absence of
    quotes) if we are using base 10. It could also represent the number 2 if
    we are using binary; the number 5 if we are using base five, or the
    number 16 if we are using hexadecimal. It's the same string in all four
    cases, but the answer to 'is it prime' is different. So the string
    itself lacks the prime property altogether. Only the natural number
    which the string represents has a prime property.

    Similarly, when we pass a halting decider a string as its input, it is meaningless to ask whether the *string* halts. The string is simply how
    we represent the computation we want to ask the decider about, and the
    decider is expected to answer about that computation, not about the string.

    *Any* program can be represented by a finite string, so it is possible
    to ask a TM about any program.

    Andr|-


    -a-a-a HHH-a-a : the outer simulator

    -a-a-a HHH_1 : the instance invoked by simulated DD

    NOBODY IS CLAIMING THEY ARE THE SAME EXECUTION INSTANCE.

    THAT IS THE FUCKING POINT.

    Andr|- proposes a concrete experiment involving these two distinct
    instances.

    You respond with:

    -a-a-a 2 + 3 = 2 + 3

    -a-a-a 2 + 3 = 5

    and a lecture about identity versus equivalence.

    HOW DOES ANY OF THAT ANSWER HIS OBJECTION?

    It doesn't.

    Two syntactically different expressions can have the same value. Two
    executions of the same code can have different states and different
    outcomes.

    But none of that establishes that your non-halting detector is correct.

    You have simply changed the subject AGAIN.

    And you have STILL not answered the actual question:

    If the outer HHH continues simulating while the nested HHH_1 retains
    its abort mechanism, what exactly happens?

    Does simulated DD eventually return?

    If not, identify the precise execution step that prevents it.

    If yes, explain why your original outer HHH reported non-halting.

    THAT IS THE TEST.

    Not whether 2 + 3 is syntactically identical to 5.

    Not whether two processes are "one-and-the-same exact same thing."

    Not whether your critics have been lying for twenty-two years.

    THE FUCKING EXECUTION TRACE.

    You have spent years demanding that everybody pay attention to every
    subtle detail of your implementation.

    Well, here is your opportunity.

    SHOW US THE DETAILS.

    Or admit that you have no technical answer to Andr|-'s objection.


    --
    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,alt.messianic,alt.buddha.short.fat.guy on Tue Nov 3 22:49:40 2026
    From Newsgroup: sci.logic

    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone
    challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH cannot
    accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with the rest
    of them. they don't even think something is broken, i do

    i'm just trying to get u focused in the right direction. failing to acknowledge the invariant ur proof breaks ain't the right direction polcott


    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from HHH1
    recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition.

    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist. >>>>>>
    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not establish >>>>>> your claimed semantic conclusion, the correctness of HHH's
    decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the inference >>>>>> establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square brackets. >>>>>>
    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension.

    Now, Peter, you have repeatedly and publicly presented yourself as >>>>>> a Christian.

    Perhaps you should seriously reflect on what that entails for your >>>>>> own conduct.

    Honesty matters. So does humility. So does representing other
    people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to
    correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support
    for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I
    have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too. >>>>>>
    Perhaps it's time to apply some of those Christian principles you >>>>>> profess to yourself, rather than lecturing everyone else about
    their supposed inability to understand 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,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 05:10:50 2026
    From Newsgroup: sci.logic

    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone >>>>>>> challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH
    cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with the rest
    of them. they don't even think something is broken, i do

    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to
    acknowledge the invariant ur proof breaks ain't the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final state.**


    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from HHH1 >>>>> recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition.

    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist. >>>>>>>
    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not
    establish your claimed semantic conclusion, the correctness of
    HHH's decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the inference >>>>>>> establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square
    brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension. >>>>>>>
    Now, Peter, you have repeatedly and publicly presented yourself >>>>>>> as a Christian.

    Perhaps you should seriously reflect on what that entails for
    your own conduct.

    Honesty matters. So does humility. So does representing other
    people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to >>>>>>> correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support >>>>>>> for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I
    have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too. >>>>>>>
    Perhaps it's time to apply some of those Christian principles you >>>>>>> profess to yourself, rather than lecturing everyone else about
    their supposed inability to understand you.












    --
    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 on Wed Nov 4 03:18:43 2026
    From Newsgroup: sci.logic

    On 11/3/2026 4:35 PM, Python wrote:
    [...]
    Someone identifies a potential bug in your code and explains how to
    expose it.
    That is the neat part of discussion! If somebody took the time to find a
    bug in your work, well, thank them!
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 03:32:54 2026
    From Newsgroup: sci.logic

    On 11/3/2026 10:49 PM, dart200 wrote:
    [...]

    Afaict, PO does not give a shit about your help!
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic on Wed Nov 4 03:42:23 2026
    From Newsgroup: sci.logic

    On 11/3/2026 2:50 PM, Python wrote:
    WHAT THE FUCK DOES THAT HAVE TO DO WITH WHAT I JUST TOLD YOU?

    I accuse you of repeatedly misrepresenting the scope of other people's agreement.

    And your answer is:

    -a-a "You can look at the record on news.giganews.com
    -a-a-a where my posts go back to 2004 and see that no
    -a-a-a one from comp.theory has ever agreed with anything
    -a-a-a like this until last Sunday."

    SO WHAT?

    Whether you waited twenty-two years, twenty-two minutes, or twenty-two centuries for someone to agree with that proposition is COMPLETELY IRRELEVANT.

    You have obtained agreement on ONE LIMITED STATEMENT.

    Congratulations.

    Nobody is trying to take that agreement away from you.

    What we are challenging is what YOU CLAIM FOLLOWS FROM IT.

    And THAT is precisely what you keep refusing to address.

    Instead, you repeatedly invoke the names of people who agreed with the limited statement, as though their agreement somehow strengthened your subsequent conclusions.

    It doesn't.

    You have turned a mathematical discussion into a story about your
    twenty-two years of struggle and your long-awaited recognition.

    But mathematics does not work that way.

    A proposition does not become more powerful because nobody agreed with
    it for twenty-two years.

    An invalid inference does not become valid because five people agree
    with its premise.

    And an objection to YOUR inference is not an objection to THEIR agreement.

    Most importantly, you have STILL not answered my accusation:

    WHY DO YOU KEEP INVOKING MY AGREEMENT TO SUPPORT CONCLUSIONS THAT I HAVE EXPLICITLY REJECTED?

    Stop telling us how long you waited for agreement.

    Stop telling us how many people agreed.

    Stop telling us who helped formulate the statement.

    NONE OF THAT PROVES YOUR NEXT STEP.

    And none of it excuses your repeated misrepresentation of what other
    people actually agreed to.


    A runner going along. PO destroys it, and said oh it would run forever.
    The poor runner was running to a bathroom, bad fish. Now its dead.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 09:33:52 2026
    From Newsgroup: sci.logic

    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone >>>>>>>> challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH
    cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with the
    rest of them. they don't even think something is broken, i do

    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the right
    direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final state.**

    which doesn't prove anything about the nature of DD. HHH causes the end
    of DD's simulation, breaking the invariant that HHH not do that, as acknowledged by sipser as well

    what does invariant mean to you polcott?


    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from HHH1 >>>>>> recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition. >>>>>>>>
    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist. >>>>>>>>
    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not
    establish your claimed semantic conclusion, the correctness of >>>>>>>> HHH's decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the
    inference establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square
    brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension. >>>>>>>>
    Now, Peter, you have repeatedly and publicly presented yourself >>>>>>>> as a Christian.

    Perhaps you should seriously reflect on what that entails for >>>>>>>> your own conduct.

    Honesty matters. So does humility. So does representing other >>>>>>>> people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to >>>>>>>> correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support >>>>>>>> for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I >>>>>>>> have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too. >>>>>>>>
    Perhaps it's time to apply some of those Christian principles >>>>>>>> you profess to yourself, rather than lecturing everyone else
    about their supposed inability to understand 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 on Wed Nov 4 11:39:27 2026
    From Newsgroup: sci.logic

    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever
    someone challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH
    cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with the
    rest of them. they don't even think something is broken, i do

    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the right
    direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final state.**

    which doesn't prove anything about the nature of DD. HHH causes the end
    of DD's simulation, breaking the invariant that HHH not do that, as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after
    simulation has been aborted or we would judge that all infinite
    loops always halt. Instead we look for a repeating state while the
    simulation continues.



    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from HHH1 >>>>>>> recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition. >>>>>>>>>
    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't >>>>>>>>> exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not
    establish your claimed semantic conclusion, the correctness of >>>>>>>>> HHH's decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement: >>>>>>>>>
    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the
    inference establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square >>>>>>>>> brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension. >>>>>>>>>
    Now, Peter, you have repeatedly and publicly presented yourself >>>>>>>>> as a Christian.

    Perhaps you should seriously reflect on what that entails for >>>>>>>>> your own conduct.

    Honesty matters. So does humility. So does representing other >>>>>>>>> people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are >>>>>>>>> misrepresenting their agreement, the appropriate response is to >>>>>>>>> correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding. >>>>>>>>> And certainly not to hide behind their names as supposed
    support for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I >>>>>>>>> have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too. >>>>>>>>>
    Perhaps it's time to apply some of those Christian principles >>>>>>>>> you profess to yourself, rather than lecturing everyone else >>>>>>>>> about their supposed inability to understand you.
















    --
    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 Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 09:46:45 2026
    From Newsgroup: sci.logic

    On 11/4/2026 3:32 AM, Chris M. Thomasson wrote:
    On 11/3/2026 10:49 PM, dart200 wrote:
    [...]

    Afaict, PO does not give a shit about your help!

    For God's sake, can you people get a grip!

    This is supposed too be a threaded message board.

    This is when you realize it's a circus and these are your chimps!
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 09:52:16 2026
    From Newsgroup: sci.logic

    On 11/4/2026 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone >>>>>>>> challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH
    cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with the
    rest of them. they don't even think something is broken, i do

    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    Will you suckers just stop with virtue signals and the dumb cross posting!

    The only valid means of knowledge is perception - seeing is believing.

    We do not accept inference, hearsay and verbal testimony as valid means
    of knowledge on this board.

    See. absfg FAQ


    failing to acknowledge the invariant ur proof breaks ain't the right
    direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final state.**


    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from HHH1 >>>>>> recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition. >>>>>>>>
    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist. >>>>>>>>
    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not
    establish your claimed semantic conclusion, the correctness of >>>>>>>> HHH's decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the
    inference establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square
    brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension. >>>>>>>>
    Now, Peter, you have repeatedly and publicly presented yourself >>>>>>>> as a Christian.

    Perhaps you should seriously reflect on what that entails for >>>>>>>> your own conduct.

    Honesty matters. So does humility. So does representing other >>>>>>>> people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to >>>>>>>> correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support >>>>>>>> for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I >>>>>>>> have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too. >>>>>>>>
    Perhaps it's time to apply some of those Christian principles >>>>>>>> you profess to yourself, rather than lecturing everyone else
    about their supposed inability to understand you.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 11:03:12 2026
    From Newsgroup: sci.logic

    On 11/4/2026 9:46 AM, Dude wrote:
    On 11/4/2026 3:32 AM, Chris M. Thomasson wrote:
    On 11/3/2026 10:49 PM, dart200 wrote:
    [...]

    Afaict, PO does not give a shit about your help!

    For God's sake, can you people get a grip!

    This is supposed too be a threaded message board.

    This is when you realize it's a circus and these are your chimps!

    I don't think PO understands the help he is getting.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 12:26:44 2026
    From Newsgroup: sci.logic

    On 11/3/2026 10:49 PM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever someone >>>>>>> challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH
    cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with the rest
    of them. they don't even think something is broken, i do

    i'm just trying to get u focused in the right direction. failing to acknowledge the invariant ur proof breaks ain't the right direction polcott

    Call me skeptical.
    On this board, we do not accept verbal testimony or hearsay as evidence
    or proof. We only accept perception as a valid means of knowledge.

    Did you, or did you not, copy and paste Alan Turing's halting problem?

    Or, are you saying you had this knowledge, a priori, outside space and time?

    P.S. You cross posted here for a reason, right?

    You came here to get enlightened?


    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from HHH1 >>>>> recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition.

    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't exist. >>>>>>>
    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not
    establish your claimed semantic conclusion, the correctness of
    HHH's decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the inference >>>>>>> establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square
    brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension. >>>>>>>
    Now, Peter, you have repeatedly and publicly presented yourself >>>>>>> as a Christian.

    Perhaps you should seriously reflect on what that entails for
    your own conduct.

    Honesty matters. So does humility. So does representing other
    people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are
    misrepresenting their agreement, the appropriate response is to >>>>>>> correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding.
    And certainly not to hide behind their names as supposed support >>>>>>> for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I
    have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility too. >>>>>>>
    Perhaps it's time to apply some of those Christian principles you >>>>>>> profess to yourself, rather than lecturing everyone else about
    their supposed inability to understand you.













    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 12:28:36 2026
    From Newsgroup: sci.logic

    On 11/4/2026 11:03 AM, Chris M. Thomasson wrote:
    On 11/4/2026 9:46 AM, Dude wrote:
    On 11/4/2026 3:32 AM, Chris M. Thomasson wrote:
    On 11/3/2026 10:49 PM, dart200 wrote:
    [...]

    Afaict, PO does not give a shit about your help!

    For God's sake, can you people get a grip!

    This is supposed too be a threaded message board.

    This is when you realize it's a circus and these are your chimps!

    I don't think PO understands the help he is getting.

    It may be a cry for help, but it also could be that some people just
    feel better when they have someone to talk to. YMMV.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 13:13:45 2026
    From Newsgroup: sci.logic

    On 11/4/2026 12:28 PM, Dude wrote:
    On 11/4/2026 11:03 AM, Chris M. Thomasson wrote:
    On 11/4/2026 9:46 AM, Dude wrote:
    On 11/4/2026 3:32 AM, Chris M. Thomasson wrote:
    On 11/3/2026 10:49 PM, dart200 wrote:
    [...]

    Afaict, PO does not give a shit about your help!

    For God's sake, can you people get a grip!

    This is supposed too be a threaded message board.

    This is when you realize it's a circus and these are your chimps!

    I don't think PO understands the help he is getting.

    It may be a cry for help, but it also could be that some people just
    feel better when they have someone to talk to. YMMV.

    Touche.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 13:40:00 2026
    From Newsgroup: sci.logic

    On 11/3/2026 12:29 AM, dart200 wrote:
    On 11/2/26 9:26 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later: >>>>>>>>>>>>>>>>>>
    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts >>>>>>>>>>>>>>>>>

    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the >>>>>>>>>>>>>>> halting semantics of DD when simulated by universal >>>>>>>>>>>>>>> simulator (EYon as defined by turing), which is the halting >>>>>>>>>>>>>>> semantics we are interested in:

    <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 >>>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted >>>>>>>>>>>>

    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which >>>>>>>> the conclusion rests upon a statement made by some presumed
    authority or witness... Because the testimony of a qualified
    authority or witness provides a reason for believing a claim, >>>>>>>> such arguments are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D >>>>>>> would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted then* >>>
    ur actively ignoring the conditional on the proof, which is that H is
    correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes prior
    to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going
    to try to post helpful comments polcott. and i suggest that ignoring
    the conditional is a major flaw in what ur trying to propose atm


    Why the fuck do you add those two groups

    cause i'm hoping u'll actually take this seriously instead of running
    away again tbh???


    alt.buddha.short.fat.guy''

    tbh i kinda hate the dud cons that infest that group. i'm tryin to make
    them less stupid but ya know how trump loving types go eh??? walk around with their head up their asshole most of the day denying basic physical facts to confirm their endlessly narcissistic biases...

    alt.messianic

    just using it as a personal journal i guess??? Efn+Efn+Efn+


    Have you always only been a troll?



    You are smarter than him. Deal with it... ;^D
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic on Wed Nov 4 22:50:55 2026
    From Newsgroup: sci.logic

    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever
    someone challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH >>>>>>>> cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with the
    rest of them. they don't even think something is broken, i do

    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the right
    direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final state.**

    which doesn't prove anything about the nature of DD. HHH causes the
    end of DD's simulation, breaking the invariant that HHH not do that,
    as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after
    simulation has been aborted or we would judge that all infinite
    loops always halt. Instead we look for a repeating state while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to prove that
    the recursion happens, HHH needs to prove that it continues to happen.
    one can't just prove the base case in an inductive proof, one needs to
    prove it for N+1 based on the premise of it for N

    HHH only proves that one recursive call happens, no where does it prove
    that the N+1 case happens. and really not only does HHH not prove that
    the recursion continues, HHH actually intervenes with that recursion
    from happening



    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from >>>>>>>> HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition. >>>>>>>>>>
    You have been told this distinction over and over again.

    You even acknowledge it, then immediately pretend it doesn't >>>>>>>>>> exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not
    establish your claimed semantic conclusion, the correctness of >>>>>>>>>> HHH's decision, or the satisfaction of Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement: >>>>>>>>>>
    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the
    inference establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square >>>>>>>>>> brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of comprehension. >>>>>>>>>>
    Now, Peter, you have repeatedly and publicly presented
    yourself as a Christian.

    Perhaps you should seriously reflect on what that entails for >>>>>>>>>> your own conduct.

    Honesty matters. So does humility. So does representing other >>>>>>>>>> people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are >>>>>>>>>> misrepresenting their agreement, the appropriate response is >>>>>>>>>> to correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding. >>>>>>>>>> And certainly not to hide behind their names as supposed
    support for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what I >>>>>>>>>> have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility >>>>>>>>>> too.

    Perhaps it's time to apply some of those Christian principles >>>>>>>>>> you profess to yourself, rather than lecturing everyone else >>>>>>>>>> about their supposed inability to understand 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 dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Wed Nov 4 22:51:49 2026
    From Newsgroup: sci.logic

    On 11/2/26 9:16 PM, Chris M. Thomasson wrote:
    On 11/2/2026 5:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring some >>>>>>>>>>>>>>>> uniquely profound understanding of the "foundations of >>>>>>>>>>>>>>>> computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does

    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the
    conclusion rests upon a statement made by some presumed authority
    or witness... Because the testimony of a qualified authority or
    witness provides a reason for believing a claim, such arguments are >>>>> often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_

    the "then" refers to aborting after the recursion is detected. sipser
    provides an exception to the correctness of the decision, explicitly
    if the simulation is _then_ aborted after the determination is made.
    this is what HHH does, and therefore the analysis by HHH of DD is
    invalidated

    it sucks to be wrong polcott, but it's better to admit ur wrong than
    continue being wrong, this is know from experience


    Sage advice.

    could u ever have foreseen sage advice coming from me chris?
    --
    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 on Thu Nov 5 05:55:13 2026
    From Newsgroup: sci.logic

    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever >>>>>>>>>>> someone challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH >>>>>>>>> cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with the
    rest of them. they don't even think something is broken, i do

    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the
    right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final state.**

    which doesn't prove anything about the nature of DD. HHH causes the
    end of DD's simulation, breaking the invariant that HHH not do that,
    as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after
    simulation has been aborted or we would judge that all infinite
    loops always halt. Instead we look for a repeating state while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to prove that
    the recursion happens, HHH needs to prove that it continues to happen.
    one can't just prove the base case in an inductive proof, one needs to
    prove it for N+1 based on the premise of it for N


    I can't help it that this is over you head.

    HHH only proves that one recursive call happens, no where does it prove
    that the N+1 case happens.

    Counter-factual.

    and really not only does HHH not prove that
    the recursion continues, HHH actually intervenes with that recursion
    from happening

    Proving that YOU WILL NOT PAY ATTENTION




    HHH breaks the invariant that sipser pointed out and therefor
    invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from >>>>>>>>> HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition. >>>>>>>>>>>
    You have been told this distinction over and over again. >>>>>>>>>>>
    You even acknowledge it, then immediately pretend it doesn't >>>>>>>>>>> exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not >>>>>>>>>>> establish your claimed semantic conclusion, the correctness >>>>>>>>>>> of HHH's decision, or the satisfaction of Sipser's premise. >>>>>>>>>>>
    You have also quietly replaced Sipser's crucial requirement: >>>>>>>>>>>
    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the >>>>>>>>>>> inference establishing that HHH's decision is correct?

    You cannot replace a proof obligation with a pair of square >>>>>>>>>>> brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of
    comprehension.

    Now, Peter, you have repeatedly and publicly presented
    yourself as a Christian.

    Perhaps you should seriously reflect on what that entails for >>>>>>>>>>> your own conduct.

    Honesty matters. So does humility. So does representing other >>>>>>>>>>> people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are >>>>>>>>>>> misrepresenting their agreement, the appropriate response is >>>>>>>>>>> to correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding. >>>>>>>>>>> And certainly not to hide behind their names as supposed >>>>>>>>>>> support for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what >>>>>>>>>>> I have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your responsibility >>>>>>>>>>> too.

    Perhaps it's time to apply some of those Christian principles >>>>>>>>>>> you profess to yourself, rather than lecturing everyone else >>>>>>>>>>> about their supposed inability to understand you.




















    --
    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 08:20:42 2026
    From Newsgroup: sci.logic

    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever >>>>>>>>>>>> someone challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH >>>>>>>>>> cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with the >>>>>> rest of them. they don't even think something is broken, i do

    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the
    right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final state.** >>>>
    which doesn't prove anything about the nature of DD. HHH causes the
    end of DD's simulation, breaking the invariant that HHH not do that,
    as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after
    simulation has been aborted or we would judge that all infinite
    loops always halt. Instead we look for a repeating state while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to prove
    that the recursion happens, HHH needs to prove that it continues to
    happen. one can't just prove the base case in an inductive proof, one
    needs to prove it for N+1 based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    HHH only proves that one recursive call happens, no where does it
    prove that the N+1 case happens.

    Counter-factual

    what does counter-factual mean to you polcott?


    -aand really not only does HHH not prove that the recursion continues,
    HHH actually intervenes with that recursion from happening

    Proving that YOU WILL NOT PAY ATTENTION

    ur willfully ignoring that i am paying attention





    HHH breaks the invariant that sipser pointed out and therefor >>>>>>>> invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from >>>>>>>>>> HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition. >>>>>>>>>>>>
    You have been told this distinction over and over again. >>>>>>>>>>>>
    You even acknowledge it, then immediately pretend it doesn't >>>>>>>>>>>> exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not >>>>>>>>>>>> establish your claimed semantic conclusion, the correctness >>>>>>>>>>>> of HHH's decision, or the satisfaction of Sipser's premise. >>>>>>>>>>>>
    You have also quietly replaced Sipser's crucial requirement: >>>>>>>>>>>>
    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the >>>>>>>>>>>> inference establishing that HHH's decision is correct? >>>>>>>>>>>>
    You cannot replace a proof obligation with a pair of square >>>>>>>>>>>> brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of
    comprehension.

    Now, Peter, you have repeatedly and publicly presented >>>>>>>>>>>> yourself as a Christian.

    Perhaps you should seriously reflect on what that entails >>>>>>>>>>>> for your own conduct.

    Honesty matters. So does humility. So does representing >>>>>>>>>>>> other people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are >>>>>>>>>>>> misrepresenting their agreement, the appropriate response is >>>>>>>>>>>> to correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding. >>>>>>>>>>>> And certainly not to hide behind their names as supposed >>>>>>>>>>>> support for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes what >>>>>>>>>>>> I have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your
    responsibility too.

    Perhaps it's time to apply some of those Christian
    principles you profess to yourself, rather than lecturing >>>>>>>>>>>> everyone else about their supposed inability to understand 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 on Thu Nov 5 10:32:25 2026
    From Newsgroup: sci.logic

    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever >>>>>>>>>>>>> someone challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH >>>>>>>>>>> cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with
    the rest of them. they don't even think something is broken, i do >>>>>>>
    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the
    right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final state.** >>>>>
    which doesn't prove anything about the nature of DD. HHH causes the >>>>> end of DD's simulation, breaking the invariant that HHH not do
    that, as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after
    simulation has been aborted or we would judge that all infinite
    loops always halt. Instead we look for a repeating state while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to prove
    that the recursion happens, HHH needs to prove that it continues to
    happen. one can't just prove the base case in an inductive proof, one
    needs to prove it for N+1 based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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.


    HHH only proves that one recursive call happens, no where does it
    prove that the N+1 case happens.

    Counter-factual

    what does counter-factual mean to you polcott?


    -aand really not only does HHH not prove that the recursion continues,
    HHH actually intervenes with that recursion from happening

    Proving that YOU WILL NOT PAY ATTENTION

    ur willfully ignoring that i am paying attention





    HHH breaks the invariant that sipser pointed out and therefor >>>>>>>>> invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from >>>>>>>>>>> HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition. >>>>>>>>>>>>>
    You have been told this distinction over and over again. >>>>>>>>>>>>>
    You even acknowledge it, then immediately pretend it >>>>>>>>>>>>> doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not >>>>>>>>>>>>> establish your claimed semantic conclusion, the correctness >>>>>>>>>>>>> of HHH's decision, or the satisfaction of Sipser's premise. >>>>>>>>>>>>>
    You have also quietly replaced Sipser's crucial requirement: >>>>>>>>>>>>>
    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the >>>>>>>>>>>>> inference establishing that HHH's decision is correct? >>>>>>>>>>>>>
    You cannot replace a proof obligation with a pair of square >>>>>>>>>>>>> brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of
    comprehension.

    Now, Peter, you have repeatedly and publicly presented >>>>>>>>>>>>> yourself as a Christian.

    Perhaps you should seriously reflect on what that entails >>>>>>>>>>>>> for your own conduct.

    Honesty matters. So does humility. So does representing >>>>>>>>>>>>> other people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are >>>>>>>>>>>>> misrepresenting their agreement, the appropriate response >>>>>>>>>>>>> is to correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding. >>>>>>>>>>>>> And certainly not to hide behind their names as supposed >>>>>>>>>>>>> support for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes >>>>>>>>>>>>> what I have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your
    responsibility too.

    Perhaps it's time to apply some of those Christian
    principles you profess to yourself, rather than lecturing >>>>>>>>>>>>> everyone else about their supposed inability to understand >>>>>>>>>>>>> you.
























    --
    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 Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 08:45:45 2026
    From Newsgroup: sci.logic

    On 11/5/2026 8:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever >>>>>>>>>>>>> someone challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr
    like 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.


    idk why u keep repeatedly confirming the halting theorum, HHH >>>>>>>>>>> cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with
    the rest of them. they don't even think something is broken, i do >>>>>>>
    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the
    right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final state.** >>>>>
    which doesn't prove anything about the nature of DD. HHH causes the >>>>> end of DD's simulation, breaking the invariant that HHH not do
    that, as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after
    simulation has been aborted or we would judge that all infinite
    loops always halt. Instead we look for a repeating state while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to prove
    that the recursion happens, HHH needs to prove that it continues to
    happen. one can't just prove the base case in an inductive proof, one
    needs to prove it for N+1 based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head

    On this board all claims posted will be met in kind.

    We accept perception as the only means of valid knowledge.

    Sorry, Pal, I'm just not seeing it.

    Go figure.



    HHH only proves that one recursive call happens, no where does it
    prove that the N+1 case happens.

    Counter-factual

    what does counter-factual mean to you polcott?


    -aand really not only does HHH not prove that the recursion continues,
    HHH actually intervenes with that recursion from happening

    Proving that YOU WILL NOT PAY ATTENTION

    ur willfully ignoring that i am paying attention





    HHH breaks the invariant that sipser pointed out and therefor >>>>>>>>> invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from >>>>>>>>>>> HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed proposition. >>>>>>>>>>>>>
    You have been told this distinction over and over again. >>>>>>>>>>>>>
    You even acknowledge it, then immediately pretend it >>>>>>>>>>>>> doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not >>>>>>>>>>>>> establish your claimed semantic conclusion, the correctness >>>>>>>>>>>>> of HHH's decision, or the satisfaction of Sipser's premise. >>>>>>>>>>>>>
    You have also quietly replaced Sipser's crucial requirement: >>>>>>>>>>>>>
    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the >>>>>>>>>>>>> inference establishing that HHH's decision is correct? >>>>>>>>>>>>>
    You cannot replace a proof obligation with a pair of square >>>>>>>>>>>>> brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK."

    I understand perfectly well what you CLAIM follows.

    I dispute that it follows.

    That is a mathematical objection, not a failure of
    comprehension.

    Now, Peter, you have repeatedly and publicly presented >>>>>>>>>>>>> yourself as a Christian.

    Perhaps you should seriously reflect on what that entails >>>>>>>>>>>>> for your own conduct.

    Honesty matters. So does humility. So does representing >>>>>>>>>>>>> other people's words faithfully.

    When someone explicitly tells you, repeatedly, that you are >>>>>>>>>>>>> misrepresenting their agreement, the appropriate response >>>>>>>>>>>>> is to correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding. >>>>>>>>>>>>> And certainly not to hide behind their names as supposed >>>>>>>>>>>>> support for your conclusions.

    You are free to believe that your proof is correct.

    You are NOT free to claim that my agreement establishes >>>>>>>>>>>>> what I have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility.

    Your treatment of other people's words is your
    responsibility too.

    Perhaps it's time to apply some of those Christian
    principles you profess to yourself, rather than lecturing >>>>>>>>>>>>> everyone else about their supposed inability to understand >>>>>>>>>>>>> you.

























    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 08:50:53 2026
    From Newsgroup: sci.logic

    On 11/4/2026 1:13 PM, Chris M. Thomasson wrote:
    On 11/4/2026 12:28 PM, Dude wrote:
    On 11/4/2026 11:03 AM, Chris M. Thomasson wrote:
    On 11/4/2026 9:46 AM, Dude wrote:
    On 11/4/2026 3:32 AM, Chris M. Thomasson wrote:
    On 11/3/2026 10:49 PM, dart200 wrote:
    [...]

    Afaict, PO does not give a shit about your help!

    For God's sake, can you people get a grip!

    This is supposed too be a threaded message board.

    This is when you realize it's a circus and these are your chimps!

    I don't think PO understands the help he is getting.

    It may be a cry for help, but it also could be that some people just
    feel better when they have someone to talk to. YMMV.

    Touche.

    Some people are highly prone to suggestion.

    Suggestibility is the psychological quality or trait of being inclined
    to accept and act upon the ideas, beliefs, or suggestions of others,
    which can alter a person's perceptions, memories, behaviors, or emotions.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 09:01:09 2026
    From Newsgroup: sci.logic

    On 11/4/2026 1:40 PM, Chris M. Thomasson wrote:
    On 11/3/2026 12:29 AM, dart200 wrote:
    On 11/2/26 9:26 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later: >>>>>>>>>>>>>>>>>>>
    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts >>>>>>>>>>>>>>>>>>

    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input. >>>>>>>>>>>>>>>>>
    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated >>>>>>>>>>>>>>>>> by HHH to determine the behavior specified by >>>>>>>>>>>>>>>>> the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the >>>>>>>>>>>>>>>> halting semantics of DD when simulated by universal >>>>>>>>>>>>>>>> simulator (EYon as defined by turing), which is the halting >>>>>>>>>>>>>>>> semantics we are interested in:

    <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 >>>>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted >>>>>>>>>>>>>

    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which >>>>>>>>> the conclusion rests upon a statement made by some presumed >>>>>>>>> authority or witness... Because the testimony of a qualified >>>>>>>>> authority or witness provides a reason for believing a claim, >>>>>>>>> such arguments are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated >>>>>>>> D would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted
    then*

    ur actively ignoring the conditional on the proof, which is that H
    is correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes
    prior to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going
    to try to post helpful comments polcott. and i suggest that ignoring
    the conditional is a major flaw in what ur trying to propose atm


    Why the fuck do you add those two groups

    cause i'm hoping u'll actually take this seriously instead of running
    away again tbh???


    alt.buddha.short.fat.guy''

    tbh i kinda hate the dud cons that infest that group. i'm tryin to
    make them less stupid but ya know how trump loving types go eh??? walk
    around with their head up their asshole most of the day denying basic
    physical facts to confirm their endlessly narcissistic biases...

    alt.messianic

    just using it as a personal journal i guess??? Efn+Efn+Efn+


    Have you always only been a troll?



    You are smarter than him. Deal with it... ;^D

    It looks like an appeal to authority fallacy - Alan Turing.

    An appeal to authority fallacy (known formally as argumentum ad
    verecundiam) occurs when someone claims that something must be true
    simply because an authority figure, expert, or celebrity said sorCowithout offering actual evidence or logical proof.

    Where's Creon?

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Thu Nov 5 11:05:06 2026
    From Newsgroup: sci.logic

    On 11/5/2026 11:01 AM, Dude wrote:
    On 11/4/2026 1:40 PM, Chris M. Thomasson wrote:
    On 11/3/2026 12:29 AM, dart200 wrote:
    On 11/2/26 9:26 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later: >>>>>>>>>>>>>>>>>>>>
    DD simulated by HHH is the only correct way to >>>>>>>>>>>>>>>>>>>> determine
    the semantic halting property of the input finite >>>>>>>>>>>>>>>>>>>> string
    of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here >>>>>>>>>>>>>>>>>>> }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts >>>>>>>>>>>>>>>>>>>

    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input. >>>>>>>>>>>>>>>>>>
    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated >>>>>>>>>>>>>>>>>> by HHH to determine the behavior specified by >>>>>>>>>>>>>>>>>> the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the >>>>>>>>>>>>>>>>> halting semantics of DD when simulated by universal >>>>>>>>>>>>>>>>> simulator (EYon as defined by turing), which is the >>>>>>>>>>>>>>>>> halting semantics we are interested in:

    <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 >>>>>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted >>>>>>>>>>>>>>

    right, but DD running forever is only a hypothetical. >>>>>>>>>>>>
    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is? >>>>>>>>>>>

    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which >>>>>>>>>> the conclusion rests upon a statement made by some presumed >>>>>>>>>> authority or witness... Because the testimony of a qualified >>>>>>>>>> authority or witness provides a reason for believing a claim, >>>>>>>>>> such arguments are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated >>>>>>>>> D would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted
    then*

    ur actively ignoring the conditional on the proof, which is that H
    is correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes
    prior to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going >>>>> to try to post helpful comments polcott. and i suggest that
    ignoring the conditional is a major flaw in what ur trying to
    propose atm


    Why the fuck do you add those two groups

    cause i'm hoping u'll actually take this seriously instead of running
    away again tbh???


    alt.buddha.short.fat.guy''

    tbh i kinda hate the dud cons that infest that group. i'm tryin to
    make them less stupid but ya know how trump loving types go eh???
    walk around with their head up their asshole most of the day denying
    basic physical facts to confirm their endlessly narcissistic biases...

    alt.messianic

    just using it as a personal journal i guess??? Efn+Efn+Efn+


    Have you always only been a troll?



    You are smarter than him. Deal with it... ;^D

    It looks like an appeal to authority fallacy - Alan Turing.

    An appeal to authority fallacy (known formally as argumentum ad
    verecundiam) occurs when someone claims that something must be true
    simply because an authority figure, expert, or celebrity said sorCowithout offering actual evidence or logical proof.

    Where's Creon?


    On the other hand an appeal to a qualified expert in the field
    is inductively strong.
    --
    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 on Thu Nov 5 09:06:41 2026
    From Newsgroup: sci.logic

    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise."

    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever >>>>>>>>>>>>>> someone challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr >>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting theorum, >>>>>>>>>>>> HHH cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with >>>>>>>> the rest of them. they don't even think something is broken, i do >>>>>>>>
    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the >>>>>>>> right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final
    state.**

    which doesn't prove anything about the nature of DD. HHH causes
    the end of DD's simulation, breaking the invariant that HHH not do >>>>>> that, as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after
    simulation has been aborted or we would judge that all infinite
    loops always halt. Instead we look for a repeating state while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to prove
    that the recursion happens, HHH needs to prove that it continues to
    happen. one can't just prove the base case in an inductive proof,
    one needs to prove it for N+1 based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i can't
    believe we're still arguing about this



    HHH only proves that one recursive call happens, no where does it
    prove that the N+1 case happens.

    Counter-factual

    what does counter-factual mean to you polcott?


    -aand really not only does HHH not prove that the recursion
    continues, HHH actually intervenes with that recursion from happening

    Proving that YOU WILL NOT PAY ATTENTION

    ur willfully ignoring that i am paying attention





    HHH breaks the invariant that sipser pointed out and therefor >>>>>>>>>> invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or from >>>>>>>>>>>> HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed >>>>>>>>>>>>>> proposition.

    You have been told this distinction over and over again. >>>>>>>>>>>>>>
    You even acknowledge it, then immediately pretend it >>>>>>>>>>>>>> doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not >>>>>>>>>>>>>> establish your claimed semantic conclusion, the
    correctness of HHH's decision, or the satisfaction of >>>>>>>>>>>>>> Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement: >>>>>>>>>>>>>>
    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the >>>>>>>>>>>>>> inference establishing that HHH's decision is correct? >>>>>>>>>>>>>>
    You cannot replace a proof obligation with a pair of >>>>>>>>>>>>>> square brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK." >>>>>>>>>>>>>>
    I understand perfectly well what you CLAIM follows. >>>>>>>>>>>>>>
    I dispute that it follows.

    That is a mathematical objection, not a failure of >>>>>>>>>>>>>> comprehension.

    Now, Peter, you have repeatedly and publicly presented >>>>>>>>>>>>>> yourself as a Christian.

    Perhaps you should seriously reflect on what that entails >>>>>>>>>>>>>> for your own conduct.

    Honesty matters. So does humility. So does representing >>>>>>>>>>>>>> other people's words faithfully.

    When someone explicitly tells you, repeatedly, that you >>>>>>>>>>>>>> are misrepresenting their agreement, the appropriate >>>>>>>>>>>>>> response is to correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of understanding. >>>>>>>>>>>>>> And certainly not to hide behind their names as supposed >>>>>>>>>>>>>> support for your conclusions.

    You are free to believe that your proof is correct. >>>>>>>>>>>>>>
    You are NOT free to claim that my agreement establishes >>>>>>>>>>>>>> what I have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility. >>>>>>>>>>>>>>
    Your treatment of other people's words is your
    responsibility too.

    Perhaps it's time to apply some of those Christian >>>>>>>>>>>>>> principles you profess to yourself, rather than lecturing >>>>>>>>>>>>>> everyone else about their supposed inability to understand >>>>>>>>>>>>>> you.


























    --
    why are we god?
    let's end war EfOa

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 09:08:42 2026
    From Newsgroup: sci.logic

    On 11/5/26 9:05 AM, olcott wrote:
    On 11/5/2026 11:01 AM, Dude wrote:
    On 11/4/2026 1:40 PM, Chris M. Thomasson wrote:
    On 11/3/2026 12:29 AM, dart200 wrote:
    On 11/2/26 9:26 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>> Oh, come on, Peter.

    There is nothing remotely mysterious here >>>>>>>>>>>>>>>>>>>>>> requiring some uniquely profound understanding of >>>>>>>>>>>>>>>>>>>>>> the "foundations of computation".


    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later: >>>>>>>>>>>>>>>>>>>>>
    DD simulated by HHH is the only correct way to >>>>>>>>>>>>>>>>>>>>> determine
    the semantic halting property of the input finite >>>>>>>>>>>>>>>>>>>>> string
    of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here >>>>>>>>>>>>>>>>>>>> }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts >>>>>>>>>>>>>>>>>>>>

    If you would pay 100% complete attention >>>>>>>>>>>>>>>>>>> you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to >>>>>>>>>>>>>>>>>>> report on whatever sequence of steps is
    directly encoded in the finite string input. >>>>>>>>>>>>>>>>>>>
    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated >>>>>>>>>>>>>>>>>>> by HHH to determine the behavior specified by >>>>>>>>>>>>>>>>>>> the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the >>>>>>>>>>>>>>>>>> halting semantics of DD when simulated by universal >>>>>>>>>>>>>>>>>> simulator (EYon as defined by turing), which is the >>>>>>>>>>>>>>>>>> halting semantics we are interested in:

    <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 >>>>>>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted >>>>>>>>>>>>>>>

    right, but DD running forever is only a hypothetical. >>>>>>>>>>>>>
    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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 >>>>>>>>>>>>>
    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is? >>>>>>>>>>>>

    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which >>>>>>>>>>> the conclusion rests upon a statement made by some presumed >>>>>>>>>>> authority or witness... Because the testimony of a qualified >>>>>>>>>>> authority or witness provides a reason for believing a claim, >>>>>>>>>>> such arguments are often inductively strong or cogent."

    key line from sipser: H correctly determines that its
    simulated D would never stop running _unless aborted then_ >>>>>>>>>>

    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted >>>>>> then*

    ur actively ignoring the conditional on the proof, which is that H >>>>>> is correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes
    prior to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still
    going to try to post helpful comments polcott. and i suggest that >>>>>> ignoring the conditional is a major flaw in what ur trying to
    propose atm


    Why the fuck do you add those two groups

    cause i'm hoping u'll actually take this seriously instead of
    running away again tbh???


    alt.buddha.short.fat.guy''

    tbh i kinda hate the dud cons that infest that group. i'm tryin to
    make them less stupid but ya know how trump loving types go eh???
    walk around with their head up their asshole most of the day denying
    basic physical facts to confirm their endlessly narcissistic biases... >>>>
    alt.messianic

    just using it as a personal journal i guess??? Efn+Efn+Efn+


    Have you always only been a troll?



    You are smarter than him. Deal with it... ;^D

    It looks like an appeal to authority fallacy - Alan Turing.

    An appeal to authority fallacy (known formally as argumentum ad
    verecundiam) occurs when someone claims that something must be true
    simply because an authority figure, expert, or celebrity said sorCo
    without offering actual evidence or logical proof.

    Where's Creon?


    On the other hand an appeal to a qualified expert in the field
    is inductively strong.


    appealing to authority has zero weight in formal math dud
    --
    why are we god?
    let's end war EfOa

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Thu Nov 5 11:57:57 2026
    From Newsgroup: sci.logic

    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever >>>>>>>>>>>>>>> someone challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting theorum, >>>>>>>>>>>>> HHH cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with >>>>>>>>> the rest of them. they don't even think something is broken, i do >>>>>>>>>
    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the >>>>>>>>> right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final
    state.**

    which doesn't prove anything about the nature of DD. HHH causes >>>>>>> the end of DD's simulation, breaking the invariant that HHH not >>>>>>> do that, as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after
    simulation has been aborted or we would judge that all infinite
    loops always halt. Instead we look for a repeating state while the >>>>>> simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to prove >>>>> that the recursion happens, HHH needs to prove that it continues to >>>>> happen. one can't just prove the base case in an inductive proof,
    one needs to prove it for N+1 based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i can't
    believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)


    HHH only proves that one recursive call happens, no where does it
    prove that the N+1 case happens.

    Counter-factual

    what does counter-factual mean to you polcott?


    -aand really not only does HHH not prove that the recursion
    continues, HHH actually intervenes with that recursion from happening >>>>
    Proving that YOU WILL NOT PAY ATTENTION

    ur willfully ignoring that i am paying attention





    HHH breaks the invariant that sipser pointed out and therefor >>>>>>>>>>> invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or >>>>>>>>>>>>> from HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of:

    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed >>>>>>>>>>>>>>> proposition.

    You have been told this distinction over and over again. >>>>>>>>>>>>>>>
    You even acknowledge it, then immediately pretend it >>>>>>>>>>>>>>> doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true"

    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not >>>>>>>>>>>>>>> establish your claimed semantic conclusion, the >>>>>>>>>>>>>>> correctness of HHH's decision, or the satisfaction of >>>>>>>>>>>>>>> Sipser's premise.

    You have also quietly replaced Sipser's crucial requirement: >>>>>>>>>>>>>>>
    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the >>>>>>>>>>>>>>> inference establishing that HHH's decision is correct? >>>>>>>>>>>>>>>
    You cannot replace a proof obligation with a pair of >>>>>>>>>>>>>>> square brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK." >>>>>>>>>>>>>>>
    I understand perfectly well what you CLAIM follows. >>>>>>>>>>>>>>>
    I dispute that it follows.

    That is a mathematical objection, not a failure of >>>>>>>>>>>>>>> comprehension.

    Now, Peter, you have repeatedly and publicly presented >>>>>>>>>>>>>>> yourself as a Christian.

    Perhaps you should seriously reflect on what that entails >>>>>>>>>>>>>>> for your own conduct.

    Honesty matters. So does humility. So does representing >>>>>>>>>>>>>>> other people's words faithfully.

    When someone explicitly tells you, repeatedly, that you >>>>>>>>>>>>>>> are misrepresenting their agreement, the appropriate >>>>>>>>>>>>>>> response is to correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of
    understanding.
    And certainly not to hide behind their names as supposed >>>>>>>>>>>>>>> support for your conclusions.

    You are free to believe that your proof is correct. >>>>>>>>>>>>>>>
    You are NOT free to claim that my agreement establishes >>>>>>>>>>>>>>> what I have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility. >>>>>>>>>>>>>>>
    Your treatment of other people's words is your
    responsibility too.

    Perhaps it's time to apply some of those Christian >>>>>>>>>>>>>>> principles you profess to yourself, rather than lecturing >>>>>>>>>>>>>>> everyone else about their supposed inability to >>>>>>>>>>>>>>> understand you.




























    --
    Copyright 2026 Olcott

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

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

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

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

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

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

    On 11/3/2026 5:13 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:50, olcott wrote:
    On 11/3/2026 1:27 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:03, olcott wrote:
    On 11/3/2026 12:20 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 09:47, olcott wrote:
    On 11/3/2026 10:35 AM, Andr|- G. Isaak wrote:
    On 2026-11-02 19:54, olcott wrote:

    <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

    Since we can see that the Professor Sipser approved
    criteria has been met then it is reasonably plausible
    (actually dead certain yet over everyone's head)
    that HHH can see this too. When HHH does see this
    then the the above "if" has been fully satisfied.

    But the "Sipser approved criterion' hasn't been met.

    You have your HHH simulating DD. Simulated DD then invokes a new >>>>>>> instance of HHH (call it HHH_1). HHH_1 then simulates a new
    instance of DD_1, which in turn calls HHH_2 and so forth.

    But that chain doesn't continue indefinitely.


    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.

    Your simply repeating yourself without actually addressing my
    point. DD

    We already have a five-way consensus on the above words, quit cheating. >>>
    There appears to be a disconnect between what others have agreed to
    and what you *think* they have agreed to. Python has pointed this out
    to you numerous times.


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

    Yes. *While* the simulation continues, DD does not reach its return instruction. That's because your HHH stops simulating (aborts) before DD reaches its return instruction;

    *A five-way consensus disagrees*
    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.

    *Thus you are a liar at this point*
    Add your agreement making this a 6-way consensus
    or I won't talk to you again.

    not because DD wouldn't ultimately reach
    its return instruction had the simulation continued just a wee bit longer.


    Pointing out a flaw in your reasoning hardly constitutes 'cheating'.
    Maybe actually address the point.

    Andr|-



    There never has been a flaw in that reasoning.
    dbush helped write the prior version.

    Your HHH claims that DD, a halting program, doesn't halt. I'd call that
    a major flaw in HHH's logic.

    The problem is that you claim to have identified a 'non-halting pattern' where no such pattern exists.

    You claim that when a function is called twice from the same address
    with no intervening conditional statements, it constitutes a non halting pattern. But there *are* conditional statements intervening which your
    HHH simply ignores. The HHH_1 which is invoked from within your DD, *conditionally* simulates DD_1. After each step in the simulation it
    checks for your 'non-halting pattern' and only continues to simulate if
    that pattern isn't met. Why does HHH not count those conditional
    statements as conditional statements?

    And Python has already called into question the accuracy of your alleged pattern but you've simply ignored him.

    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 11:03:16 2026
    From Newsgroup: sci.logic

    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" whenever >>>>>>>>>>>>>>>> someone challenges YOUR conclusions.


    You can look at the record on news.giganews.com
    where my posts go back to 2004 and see that no
    one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting theorum, >>>>>>>>>>>>>> HHH cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles with >>>>>>>>>> the rest of them. they don't even think something is broken, i do >>>>>>>>>>
    i'm just trying to get u focused in the right direction.

    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't the >>>>>>>>>> right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final >>>>>>>>> state.**

    which doesn't prove anything about the nature of DD. HHH causes >>>>>>>> the end of DD's simulation, breaking the invariant that HHH not >>>>>>>> do that, as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after
    simulation has been aborted or we would judge that all infinite
    loops always halt. Instead we look for a repeating state while the >>>>>>> simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to
    prove that the recursion happens, HHH needs to prove that it
    continues to happen. one can't just prove the base case in an
    inductive proof, one needs to prove it for N+1 based on the
    premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i can't
    believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total halting
    decider!

    as such, it's expected that HHH will failed to correctly compute the
    halting semantics of some input, of which DD is one example...

    u seem to understand this, but i don't know what is so hard about
    accepting it polcott



    HHH only proves that one recursive call happens, no where does it >>>>>> prove that the N+1 case happens.

    Counter-factual

    what does counter-factual mean to you polcott?


    -aand really not only does HHH not prove that the recursion
    continues, HHH actually intervenes with that recursion from happening >>>>>
    Proving that YOU WILL NOT PAY ATTENTION

    ur willfully ignoring that i am paying attention





    HHH breaks the invariant that sipser pointed out and
    therefor invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or >>>>>>>>>>>>>> from HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of: >>>>>>>>>>>>>>>>
    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed >>>>>>>>>>>>>>>> proposition.

    You have been told this distinction over and over again. >>>>>>>>>>>>>>>>
    You even acknowledge it, then immediately pretend it >>>>>>>>>>>>>>>> doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true" >>>>>>>>>>>>>>>>
    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do not >>>>>>>>>>>>>>>> establish your claimed semantic conclusion, the >>>>>>>>>>>>>>>> correctness of HHH's decision, or the satisfaction of >>>>>>>>>>>>>>>> Sipser's premise.

    You have also quietly replaced Sipser's crucial >>>>>>>>>>>>>>>> requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the >>>>>>>>>>>>>>>> inference establishing that HHH's decision is correct? >>>>>>>>>>>>>>>>
    You cannot replace a proof obligation with a pair of >>>>>>>>>>>>>>>> square brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK." >>>>>>>>>>>>>>>>
    I understand perfectly well what you CLAIM follows. >>>>>>>>>>>>>>>>
    I dispute that it follows.

    That is a mathematical objection, not a failure of >>>>>>>>>>>>>>>> comprehension.

    Now, Peter, you have repeatedly and publicly presented >>>>>>>>>>>>>>>> yourself as a Christian.

    Perhaps you should seriously reflect on what that >>>>>>>>>>>>>>>> entails for your own conduct.

    Honesty matters. So does humility. So does representing >>>>>>>>>>>>>>>> other people's words faithfully.

    When someone explicitly tells you, repeatedly, that you >>>>>>>>>>>>>>>> are misrepresenting their agreement, the appropriate >>>>>>>>>>>>>>>> response is to correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of >>>>>>>>>>>>>>>> understanding.
    And certainly not to hide behind their names as supposed >>>>>>>>>>>>>>>> support for your conclusions.

    You are free to believe that your proof is correct. >>>>>>>>>>>>>>>>
    You are NOT free to claim that my agreement establishes >>>>>>>>>>>>>>>> what I have explicitly and repeatedly denied.

    Your mathematical argument is your responsibility. >>>>>>>>>>>>>>>>
    Your treatment of other people's words is your >>>>>>>>>>>>>>>> responsibility too.

    Perhaps it's time to apply some of those Christian >>>>>>>>>>>>>>>> principles you profess to yourself, rather than >>>>>>>>>>>>>>>> lecturing everyone else about their supposed inability >>>>>>>>>>>>>>>> to understand 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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 13:08:54 2026
    From Newsgroup: sci.logic

    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" >>>>>>>>>>>>>>>>> whenever someone challenges YOUR conclusions. >>>>>>>>>>>>>>>>>

    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>> one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting theorum, >>>>>>>>>>>>>>> HHH cannot accurately decide on DD Efn+


    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles >>>>>>>>>>> with the rest of them. they don't even think something is >>>>>>>>>>> broken, i do

    i'm just trying to get u focused in the right direction. >>>>>>>>>>
    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't >>>>>>>>>>> the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final >>>>>>>>>> state.**

    which doesn't prove anything about the nature of DD. HHH causes >>>>>>>>> the end of DD's simulation, breaking the invariant that HHH not >>>>>>>>> do that, as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after >>>>>>>> simulation has been aborted or we would judge that all infinite >>>>>>>> loops always halt. Instead we look for a repeating state while the >>>>>>>> simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to
    prove that the recursion happens, HHH needs to prove that it
    continues to happen. one can't just prove the base case in an
    inductive proof, one needs to prove it for N+1 based on the
    premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i can't
    believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    as such, it's expected that HHH will failed to correctly compute the
    halting semantics of some input, of which DD is one example...

    u seem to understand this, but i don't know what is so hard about
    accepting it polcott



    HHH only proves that one recursive call happens, no where does it >>>>>>> prove that the N+1 case happens.

    Counter-factual

    what does counter-factual mean to you polcott?


    -aand really not only does HHH not prove that the recursion
    continues, HHH actually intervenes with that recursion from
    happening

    Proving that YOU WILL NOT PAY ATTENTION

    ur willfully ignoring that i am paying attention





    HHH breaks the invariant that sipser pointed out and >>>>>>>>>>>>> therefor invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or >>>>>>>>>>>>>>> from HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of: >>>>>>>>>>>>>>>>>
    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed >>>>>>>>>>>>>>>>> proposition.

    You have been told this distinction over and over again. >>>>>>>>>>>>>>>>>
    You even acknowledge it, then immediately pretend it >>>>>>>>>>>>>>>>> doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true" >>>>>>>>>>>>>>>>>
    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do >>>>>>>>>>>>>>>>> not establish your claimed semantic conclusion, the >>>>>>>>>>>>>>>>> correctness of HHH's decision, or the satisfaction of >>>>>>>>>>>>>>>>> Sipser's premise.

    You have also quietly replaced Sipser's crucial >>>>>>>>>>>>>>>>> requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is the >>>>>>>>>>>>>>>>> inference establishing that HHH's decision is correct? >>>>>>>>>>>>>>>>>
    You cannot replace a proof obligation with a pair of >>>>>>>>>>>>>>>>> square brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK." >>>>>>>>>>>>>>>>>
    I understand perfectly well what you CLAIM follows. >>>>>>>>>>>>>>>>>
    I dispute that it follows.

    That is a mathematical objection, not a failure of >>>>>>>>>>>>>>>>> comprehension.

    Now, Peter, you have repeatedly and publicly presented >>>>>>>>>>>>>>>>> yourself as a Christian.

    Perhaps you should seriously reflect on what that >>>>>>>>>>>>>>>>> entails for your own conduct.

    Honesty matters. So does humility. So does representing >>>>>>>>>>>>>>>>> other people's words faithfully.

    When someone explicitly tells you, repeatedly, that you >>>>>>>>>>>>>>>>> are misrepresenting their agreement, the appropriate >>>>>>>>>>>>>>>>> response is to correct your representation.

    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of >>>>>>>>>>>>>>>>> understanding.
    And certainly not to hide behind their names as >>>>>>>>>>>>>>>>> supposed support for your conclusions.

    You are free to believe that your proof is correct. >>>>>>>>>>>>>>>>>
    You are NOT free to claim that my agreement establishes >>>>>>>>>>>>>>>>> what I have explicitly and repeatedly denied. >>>>>>>>>>>>>>>>>
    Your mathematical argument is your responsibility. >>>>>>>>>>>>>>>>>
    Your treatment of other people's words is your >>>>>>>>>>>>>>>>> responsibility too.

    Perhaps it's time to apply some of those Christian >>>>>>>>>>>>>>>>> principles you profess to yourself, rather than >>>>>>>>>>>>>>>>> lecturing everyone else about their supposed inability >>>>>>>>>>>>>>>>> to understand you.
































    --
    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 12:12:39 2026
    From Newsgroup: sci.logic

    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" >>>>>>>>>>>>>>>>>> whenever someone challenges YOUR conclusions. >>>>>>>>>>>>>>>>>>

    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>> one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting >>>>>>>>>>>>>>>> theorum, HHH cannot accurately decide on DD Efn+ >>>>>>>>>>>>>>>>

    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles >>>>>>>>>>>> with the rest of them. they don't even think something is >>>>>>>>>>>> broken, i do

    i'm just trying to get u focused in the right direction. >>>>>>>>>>>
    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't >>>>>>>>>>>> the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final >>>>>>>>>>> state.**

    which doesn't prove anything about the nature of DD. HHH
    causes the end of DD's simulation, breaking the invariant that >>>>>>>>>> HHH not do that, as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after >>>>>>>>> simulation has been aborted or we would judge that all infinite >>>>>>>>> loops always halt. Instead we look for a repeating state while the >>>>>>>>> simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to >>>>>>>> prove that the recursion happens, HHH needs to prove that it
    continues to happen. one can't just prove the base case in an >>>>>>>> inductive proof, one needs to prove it for N+1 based on the
    premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i can't
    believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total halting
    decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation works...


    as such, it's expected that HHH will failed to correctly compute the
    halting semantics of some input, of which DD is one example...

    u seem to understand this, but i don't know what is so hard about
    accepting it polcott



    HHH only proves that one recursive call happens, no where does >>>>>>>> it prove that the N+1 case happens.

    Counter-factual

    what does counter-factual mean to you polcott?


    -aand really not only does HHH not prove that the recursion
    continues, HHH actually intervenes with that recursion from
    happening

    Proving that YOU WILL NOT PAY ATTENTION

    ur willfully ignoring that i am paying attention





    HHH breaks the invariant that sipser pointed out and >>>>>>>>>>>>>> therefor invalidates it's proof

    u do know what an invariant is, correct?


    this doesn't stop EYon(DD) from being a halting machine or >>>>>>>>>>>>>>>> from HHH1 recognizing DD correctly

    And in this very message, you accuse Andr|- of: >>>>>>>>>>>>>>>>>>
    -a-a-a "rebutting the five-way consensus"

    HE IS NOT.

    He is challenging YOUR INFERENCES from the agreed >>>>>>>>>>>>>>>>>> proposition.

    You have been told this distinction over and over again. >>>>>>>>>>>>>>>>>>
    You even acknowledge it, then immediately pretend it >>>>>>>>>>>>>>>>>> doesn't exist.

    And this:

    -a-a-a "Your own words prove that this is true" >>>>>>>>>>>>>>>>>>
    NO, THEY FUCKING DON'T.

    My words establish exactly what I agreed to. They do >>>>>>>>>>>>>>>>>> not establish your claimed semantic conclusion, the >>>>>>>>>>>>>>>>>> correctness of HHH's decision, or the satisfaction of >>>>>>>>>>>>>>>>>> Sipser's premise.

    You have also quietly replaced Sipser's crucial >>>>>>>>>>>>>>>>>> requirement:

    -a-a-a "H correctly determines"

    with:

    -a-a-a "[we can see]"

    WHO can see? WHAT exactly has been proved? WHERE is >>>>>>>>>>>>>>>>>> the inference establishing that HHH's decision is >>>>>>>>>>>>>>>>>> correct?

    You cannot replace a proof obligation with a pair of >>>>>>>>>>>>>>>>>> square brackets.

    And please spare me:

    -a-a-a "That you don't understand that yet is OK." >>>>>>>>>>>>>>>>>>
    I understand perfectly well what you CLAIM follows. >>>>>>>>>>>>>>>>>>
    I dispute that it follows.

    That is a mathematical objection, not a failure of >>>>>>>>>>>>>>>>>> comprehension.

    Now, Peter, you have repeatedly and publicly presented >>>>>>>>>>>>>>>>>> yourself as a Christian.

    Perhaps you should seriously reflect on what that >>>>>>>>>>>>>>>>>> entails for your own conduct.

    Honesty matters. So does humility. So does >>>>>>>>>>>>>>>>>> representing other people's words faithfully. >>>>>>>>>>>>>>>>>>
    When someone explicitly tells you, repeatedly, that >>>>>>>>>>>>>>>>>> you are misrepresenting their agreement, the >>>>>>>>>>>>>>>>>> appropriate response is to correct your representation. >>>>>>>>>>>>>>>>>>
    Not to keep doing it.
    Not to accuse your critics of cheating.
    Not to dismiss their objections as failures of >>>>>>>>>>>>>>>>>> understanding.
    And certainly not to hide behind their names as >>>>>>>>>>>>>>>>>> supposed support for your conclusions.

    You are free to believe that your proof is correct. >>>>>>>>>>>>>>>>>>
    You are NOT free to claim that my agreement >>>>>>>>>>>>>>>>>> establishes what I have explicitly and repeatedly denied. >>>>>>>>>>>>>>>>>>
    Your mathematical argument is your responsibility. >>>>>>>>>>>>>>>>>>
    Your treatment of other people's words is your >>>>>>>>>>>>>>>>>> responsibility too.

    Perhaps it's time to apply some of those Christian >>>>>>>>>>>>>>>>>> principles you profess to yourself, rather than >>>>>>>>>>>>>>>>>> lecturing everyone else about their supposed inability >>>>>>>>>>>>>>>>>> to understand 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 on Thu Nov 5 14:21:10 2026
    From Newsgroup: sci.logic

    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" >>>>>>>>>>>>>>>>>>> whenever someone challenges YOUR conclusions. >>>>>>>>>>>>>>>>>>>

    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting >>>>>>>>>>>>>>>>> theorum, HHH cannot accurately decide on DD Efn+ >>>>>>>>>>>>>>>>>

    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles >>>>>>>>>>>>> with the rest of them. they don't even think something is >>>>>>>>>>>>> broken, i do

    i'm just trying to get u focused in the right direction. >>>>>>>>>>>>
    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't >>>>>>>>>>>>> the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated final >>>>>>>>>>>> state.**

    which doesn't prove anything about the nature of DD. HHH >>>>>>>>>>> causes the end of DD's simulation, breaking the invariant >>>>>>>>>>> that HHH not do that, as acknowledged by sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after >>>>>>>>>> simulation has been aborted or we would judge that all infinite >>>>>>>>>> loops always halt. Instead we look for a repeating state while >>>>>>>>>> the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to >>>>>>>>> prove that the recursion happens, HHH needs to prove that it >>>>>>>>> continues to happen. one can't just prove the base case in an >>>>>>>>> inductive proof, one needs to prove it for N+1 based on the >>>>>>>>> premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i
    can't believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total halting
    decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.


    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation works...


    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.
    --
    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 12:31:50 2026
    From Newsgroup: sci.logic

    On 11/5/2026 9:08 AM, dart200 wrote:
    [...]
    appealing to authority has zero weight in formal math dud

    Well, afaict, dart200 is smarter than PO.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 12:34:29 2026
    From Newsgroup: sci.logic

    On 11/4/2026 10:51 PM, dart200 wrote:
    On 11/2/26 9:16 PM, Chris M. Thomasson wrote:
    On 11/2/2026 5:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the >>>>>> conclusion rests upon a statement made by some presumed authority >>>>>> or witness... Because the testimony of a qualified authority or
    witness provides a reason for believing a claim, such arguments
    are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_

    the "then" refers to aborting after the recursion is detected. sipser
    provides an exception to the correctness of the decision, explicitly
    if the simulation is _then_ aborted after the determination is made.
    this is what HHH does, and therefore the analysis by HHH of DD is
    invalidated

    it sucks to be wrong polcott, but it's better to admit ur wrong than
    continue being wrong, this is know from experience


    Sage advice.

    could u ever have foreseen sage advice coming from me chris?


    Difficult question. I think so. :^)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 12:41:24 2026
    From Newsgroup: sci.logic

    On 11/5/2026 9:08 AM, dart200 wrote:
    On 11/5/26 9:05 AM, olcott wrote:
    On 11/5/2026 11:01 AM, Dude wrote:
    On 11/4/2026 1:40 PM, Chris M. Thomasson wrote:
    On 11/3/2026 12:29 AM, dart200 wrote:
    On 11/2/26 9:26 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>> On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>> Oh, come on, Peter.

    There is nothing remotely mysterious here >>>>>>>>>>>>>>>>>>>>>>> requiring some uniquely profound understanding of >>>>>>>>>>>>>>>>>>>>>>> the "foundations of computation". >>>>>>>>>>>>>>>>>>>>>>>

    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later: >>>>>>>>>>>>>>>>>>>>>>
    DD simulated by HHH is the only correct way to >>>>>>>>>>>>>>>>>>>>>> determine
    the semantic halting property of the input finite >>>>>>>>>>>>>>>>>>>>>> string
    of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here >>>>>>>>>>>>>>>>>>>>> }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts >>>>>>>>>>>>>>>>>>>>>

    If you would pay 100% complete attention >>>>>>>>>>>>>>>>>>>> you would see that computable functions >>>>>>>>>>>>>>>>>>>> are not allowed to do that.

    Computable functions are only allowed to >>>>>>>>>>>>>>>>>>>> report on whatever sequence of steps is >>>>>>>>>>>>>>>>>>>> directly encoded in the finite string input. >>>>>>>>>>>>>>>>>>>>
    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated >>>>>>>>>>>>>>>>>>>> by HHH to determine the behavior specified by >>>>>>>>>>>>>>>>>>>> the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the >>>>>>>>>>>>>>>>>>> halting semantics of DD when simulated by universal >>>>>>>>>>>>>>>>>>> simulator (EYon as defined by turing), which is the >>>>>>>>>>>>>>>>>>> halting semantics we are interested in:

    <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 >>>>>>>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted >>>>>>>>>>>>>>>>

    right, but DD running forever is only a hypothetical. >>>>>>>>>>>>>>
    The ONLY point that I am making is the above point. >>>>>>>>>>>>>> Every other point is a mere distraction away from
    the above point.

    <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 >>>>>>>>>>>>>>
    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is? >>>>>>>>>>>>>

    I know what that deductive fallacy is on the other hand >>>>>>>>>>>>
    "An argument from authority is an inductive argument in >>>>>>>>>>>> which the conclusion rests upon a statement made by some >>>>>>>>>>>> presumed authority or witness... Because the testimony of a >>>>>>>>>>>> qualified authority or witness provides a reason for
    believing a claim, such arguments are often inductively >>>>>>>>>>>> strong or cogent."

    key line from sipser: H correctly determines that its
    simulated D would never stop running _unless aborted then_ >>>>>>>>>>>

    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is
    aborted then*

    ur actively ignoring the conditional on the proof, which is that >>>>>>> H is correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes >>>>>>> prior to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still
    going to try to post helpful comments polcott. and i suggest that >>>>>>> ignoring the conditional is a major flaw in what ur trying to
    propose atm


    Why the fuck do you add those two groups

    cause i'm hoping u'll actually take this seriously instead of
    running away again tbh???


    alt.buddha.short.fat.guy''

    tbh i kinda hate the dud cons that infest that group. i'm tryin to
    make them less stupid but ya know how trump loving types go eh???
    walk around with their head up their asshole most of the day
    denying basic physical facts to confirm their endlessly
    narcissistic biases...

    alt.messianic

    just using it as a personal journal i guess??? Efn+Efn+Efn+


    Have you always only been a troll?



    You are smarter than him. Deal with it... ;^D

    It looks like an appeal to authority fallacy - Alan Turing.

    An appeal to authority fallacy (known formally as argumentum ad
    verecundiam) occurs when someone claims that something must be true
    simply because an authority figure, expert, or celebrity said sorCo
    without offering actual evidence or logical proof.

    Where's Creon?


    On the other hand an appeal to a qualified expert in the field
    is inductively strong.


    appealing to authority has zero weight in formal math dud

    This is a formal math problem? I thought it was a logic problem.

    Apparently, Alan Turing proved in 1936rCo1937 that the problem is
    undecidable (meaning no general algorithm or mathematical procedure can
    solve it for every possible case) using a rigorous proof by
    contradiction (similar to a mathematical paradox).
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic on Thu Nov 5 14:59:05 2026
    From Newsgroup: sci.logic

    On 11/5/2026 2:41 PM, Dude wrote:
    On 11/5/2026 9:08 AM, dart200 wrote:
    On 11/5/26 9:05 AM, olcott wrote:
    On 11/5/2026 11:01 AM, Dude wrote:
    On 11/4/2026 1:40 PM, Chris M. Thomasson wrote:
    On 11/3/2026 12:29 AM, dart200 wrote:
    On 11/2/26 9:26 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/1/26 6:57 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/1/2026 8:31 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>>> Oh, come on, Peter.

    There is nothing remotely mysterious here >>>>>>>>>>>>>>>>>>>>>>>> requiring some uniquely profound understanding >>>>>>>>>>>>>>>>>>>>>>>> of the "foundations of computation". >>>>>>>>>>>>>>>>>>>>>>>>

    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later: >>>>>>>>>>>>>>>>>>>>>>>
    DD simulated by HHH is the only correct way to >>>>>>>>>>>>>>>>>>>>>>> determine
    the semantic halting property of the input finite >>>>>>>>>>>>>>>>>>>>>>> string
    of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here >>>>>>>>>>>>>>>>>>>>>> }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts >>>>>>>>>>>>>>>>>>>>>>

    If you would pay 100% complete attention >>>>>>>>>>>>>>>>>>>>> you would see that computable functions >>>>>>>>>>>>>>>>>>>>> are not allowed to do that.

    Computable functions are only allowed to >>>>>>>>>>>>>>>>>>>>> report on whatever sequence of steps is >>>>>>>>>>>>>>>>>>>>> directly encoded in the finite string input. >>>>>>>>>>>>>>>>>>>>>
    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated >>>>>>>>>>>>>>>>>>>>> by HHH to determine the behavior specified by >>>>>>>>>>>>>>>>>>>>> the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the >>>>>>>>>>>>>>>>>>>> halting semantics of DD when simulated by universal >>>>>>>>>>>>>>>>>>>> simulator (EYon as defined by turing), which is the >>>>>>>>>>>>>>>>>>>> halting semantics we are interested in: >>>>>>>>>>>>>>>>>>>>
    <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 >>>>>>>>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted >>>>>>>>>>>>>>>>>

    right, but DD running forever is only a hypothetical. >>>>>>>>>>>>>>>
    The ONLY point that I am making is the above point. >>>>>>>>>>>>>>> Every other point is a mere distraction away from >>>>>>>>>>>>>>> the above point.

    <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 >>>>>>>>>>>>>>>
    The above point almost completely proves that the >>>>>>>>>>>>>>> requirements of the above paragraph have been met. >>>>>>>>>>>>>>
    u don't know what an argument from authority fallacy is? >>>>>>>>>>>>>>

    I know what that deductive fallacy is on the other hand >>>>>>>>>>>>>
    "An argument from authority is an inductive argument in >>>>>>>>>>>>> which the conclusion rests upon a statement made by some >>>>>>>>>>>>> presumed authority or witness... Because the testimony of a >>>>>>>>>>>>> qualified authority or witness provides a reason for >>>>>>>>>>>>> believing a claim, such arguments are often inductively >>>>>>>>>>>>> strong or cogent."

    key line from sipser: H correctly determines that its >>>>>>>>>>>> simulated D would never stop running _unless aborted then_ >>>>>>>>>>>>

    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated >>>>>>>>>>> to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is
    aborted then*

    ur actively ignoring the conditional on the proof, which is that >>>>>>>> H is correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes >>>>>>>> prior to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still >>>>>>>> going to try to post helpful comments polcott. and i suggest
    that ignoring the conditional is a major flaw in what ur trying >>>>>>>> to propose atm


    Why the fuck do you add those two groups

    cause i'm hoping u'll actually take this seriously instead of
    running away again tbh???


    alt.buddha.short.fat.guy''

    tbh i kinda hate the dud cons that infest that group. i'm tryin to >>>>>> make them less stupid but ya know how trump loving types go eh??? >>>>>> walk around with their head up their asshole most of the day
    denying basic physical facts to confirm their endlessly
    narcissistic biases...

    alt.messianic

    just using it as a personal journal i guess??? Efn+Efn+Efn+


    Have you always only been a troll?



    You are smarter than him. Deal with it... ;^D

    It looks like an appeal to authority fallacy - Alan Turing.

    An appeal to authority fallacy (known formally as argumentum ad
    verecundiam) occurs when someone claims that something must be true
    simply because an authority figure, expert, or celebrity said sorCo
    without offering actual evidence or logical proof.

    Where's Creon?


    On the other hand an appeal to a qualified expert in the field
    is inductively strong.


    appealing to authority has zero weight in formal math dud

    This is a formal math problem? I thought it was a logic problem.

    Apparently, Alan Turing proved in 1936rCo1937 that the problem is undecidable (meaning no general algorithm or mathematical procedure can solve it for every possible case) using a rigorous proof by
    contradiction (similar to a mathematical paradox).

    I have focused 28 years of primary research by
    reverse-engineering the fundamental nature of
    pathological self-reference from first principles.
    22 years of this work is still shown on comp.theory

    My work on the the
    Halting Theorem,
    Liar Paradox,
    Tarski Undefinability Theorem
    1931 G||del Incompleteness
    are mere aspects of this 28 year project.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    A nearly unassailable 2000 year old paradox
    is fully resolved in four lines of Prolog code.

    My work on the halting theorem is isomorphic to
    the above four lines of Prolog code. HHH is
    essentially performing unify_with_occurs_check()
    --
    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 12:59:19 2026
    From Newsgroup: sci.logic

    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" >>>>>>>>>>>>>>>>>>>> whenever someone challenges YOUR conclusions. >>>>>>>>>>>>>>>>>>>>

    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting >>>>>>>>>>>>>>>>>> theorum, HHH cannot accurately decide on DD Efn+ >>>>>>>>>>>>>>>>>>

    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles >>>>>>>>>>>>>> with the rest of them. they don't even think something is >>>>>>>>>>>>>> broken, i do

    i'm just trying to get u focused in the right direction. >>>>>>>>>>>>>
    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks ain't >>>>>>>>>>>>>> the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated >>>>>>>>>>>>> final state.**

    which doesn't prove anything about the nature of DD. HHH >>>>>>>>>>>> causes the end of DD's simulation, breaking the invariant >>>>>>>>>>>> that HHH not do that, as acknowledged by sipser as well >>>>>>>>>>>>
    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after >>>>>>>>>>> simulation has been aborted or we would judge that all infinite >>>>>>>>>>> loops always halt. Instead we look for a repeating state >>>>>>>>>>> while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an
    overgeneralization fallacy polcott. not only does HHH need to >>>>>>>>>> prove that the recursion happens, HHH needs to prove that it >>>>>>>>>> continues to happen. one can't just prove the base case in an >>>>>>>>>> inductive proof, one needs to prove it for N+1 based on the >>>>>>>>>> premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i
    can't believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total
    halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting decider, and
    HHH demonstrates quite well by failing to compute DD's correct halting semantics



    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation works...


    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.

    --
    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 on Thu Nov 5 15:06:37 2026
    From Newsgroup: sci.logic

    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote:
    You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" >>>>>>>>>>>>>>>>>>>>> whenever someone challenges YOUR conclusions. >>>>>>>>>>>>>>>>>>>>>

    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting >>>>>>>>>>>>>>>>>>> theorum, HHH cannot accurately decide on DD Efn+ >>>>>>>>>>>>>>>>>>>

    You keep jumping ahead five steps before
    I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in circles >>>>>>>>>>>>>>> with the rest of them. they don't even think something is >>>>>>>>>>>>>>> broken, i do

    i'm just trying to get u focused in the right direction. >>>>>>>>>>>>>>
    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks >>>>>>>>>>>>>>> ain't the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated >>>>>>>>>>>>>> final state.**

    which doesn't prove anything about the nature of DD. HHH >>>>>>>>>>>>> causes the end of DD's simulation, breaking the invariant >>>>>>>>>>>>> that HHH not do that, as acknowledged by sipser as well >>>>>>>>>>>>>
    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens after >>>>>>>>>>>> simulation has been aborted or we would judge that all infinite >>>>>>>>>>>> loops always halt. Instead we look for a repeating state >>>>>>>>>>>> while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an >>>>>>>>>>> overgeneralization fallacy polcott. not only does HHH need to >>>>>>>>>>> prove that the recursion happens, HHH needs to prove that it >>>>>>>>>>> continues to happen. one can't just prove the base case in an >>>>>>>>>>> inductive proof, one needs to prove it for N+1 based on the >>>>>>>>>>> premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i
    can't believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total
    halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting decider, and
    HHH demonstrates quite well by failing to compute DD's correct halting semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.



    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation works...


    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.


    --
    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 13:12:11 2026
    From Newsgroup: sci.logic

    On 11/5/26 1:06 PM, olcott wrote:
    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>> You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" >>>>>>>>>>>>>>>>>>>>>> whenever someone challenges YOUR conclusions. >>>>>>>>>>>>>>>>>>>>>>

    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting >>>>>>>>>>>>>>>>>>>> theorum, HHH cannot accurately decide on DD Efn+ >>>>>>>>>>>>>>>>>>>>

    You keep jumping ahead five steps before >>>>>>>>>>>>>>>>>>> I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in >>>>>>>>>>>>>>>> circles with the rest of them. they don't even think >>>>>>>>>>>>>>>> something is broken, i do

    i'm just trying to get u focused in the right direction. >>>>>>>>>>>>>>>
    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks >>>>>>>>>>>>>>>> ain't the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated >>>>>>>>>>>>>>> final state.**

    which doesn't prove anything about the nature of DD. HHH >>>>>>>>>>>>>> causes the end of DD's simulation, breaking the invariant >>>>>>>>>>>>>> that HHH not do that, as acknowledged by sipser as well >>>>>>>>>>>>>>
    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens >>>>>>>>>>>>> after
    simulation has been aborted or we would judge that all >>>>>>>>>>>>> infinite
    loops always halt. Instead we look for a repeating state >>>>>>>>>>>>> while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an >>>>>>>>>>>> overgeneralization fallacy polcott. not only does HHH need >>>>>>>>>>>> to prove that the recursion happens, HHH needs to prove that >>>>>>>>>>>> it continues to happen. one can't just prove the base case >>>>>>>>>>>> in an inductive proof, one needs to prove it for N+1 based >>>>>>>>>>>> on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i >>>>>>>> can't believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total
    halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting decider, and
    HHH demonstrates quite well by failing to compute DD's correct halting
    semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.

    polcott, it's a very reasonable to be concerned about computing/proving
    the true halting semantics of any given machine

    i'm not sure what ur disagreement is




    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation works...


    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.




    --
    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 on Thu Nov 5 15:37:15 2026
    From Newsgroup: sci.logic

    On 11/5/2026 3:12 PM, dart200 wrote:
    On 11/5/26 1:06 PM, olcott wrote:
    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote:
    On 11/3/26 2:40 PM, olcott wrote:
    On 11/3/2026 4:33 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>> You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" >>>>>>>>>>>>>>>>>>>>>>> whenever someone challenges YOUR conclusions. >>>>>>>>>>>>>>>>>>>>>>>

    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting >>>>>>>>>>>>>>>>>>>>> theorum, HHH cannot accurately decide on DD Efn+ >>>>>>>>>>>>>>>>>>>>>

    You keep jumping ahead five steps before >>>>>>>>>>>>>>>>>>>> I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in >>>>>>>>>>>>>>>>> circles with the rest of them. they don't even think >>>>>>>>>>>>>>>>> something is broken, i do

    i'm just trying to get u focused in the right direction. >>>>>>>>>>>>>>>>
    Your assumption that I am incorrect prevents
    you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks >>>>>>>>>>>>>>>>> ain't the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated >>>>>>>>>>>>>>>> final state.**

    which doesn't prove anything about the nature of DD. HHH >>>>>>>>>>>>>>> causes the end of DD's simulation, breaking the invariant >>>>>>>>>>>>>>> that HHH not do that, as acknowledged by sipser as well >>>>>>>>>>>>>>>
    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens >>>>>>>>>>>>>> after
    simulation has been aborted or we would judge that all >>>>>>>>>>>>>> infinite
    loops always halt. Instead we look for a repeating state >>>>>>>>>>>>>> while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an >>>>>>>>>>>>> overgeneralization fallacy polcott. not only does HHH need >>>>>>>>>>>>> to prove that the recursion happens, HHH needs to prove >>>>>>>>>>>>> that it continues to happen. one can't just prove the base >>>>>>>>>>>>> case in an inductive proof, one needs to prove it for N+1 >>>>>>>>>>>>> based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i >>>>>>>>> can't believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total
    halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting decider, and
    HHH demonstrates quite well by failing to compute DD's correct
    halting semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.

    polcott, it's a very reasonable to be concerned about computing/proving
    the true halting semantics of any given machine

    i'm not sure what ur disagreement is


    Math asks for the logically impossible and then
    blames computation when this request is not fulfilled.

    When the request is properly framed as finite
    string transformation rules applied to finite
    string inputs then this request can be fulfilled.




    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation works...


    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.






    --
    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 13:45:58 2026
    From Newsgroup: sci.logic

    On 11/5/26 1:37 PM, olcott wrote:
    On 11/5/2026 3:12 PM, dart200 wrote:
    On 11/5/26 1:06 PM, olcott wrote:
    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:33 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>>> You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" >>>>>>>>>>>>>>>>>>>>>>>> whenever someone challenges YOUR conclusions. >>>>>>>>>>>>>>>>>>>>>>>>

    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with anythingr >>>>>>>>>>>>>>>>>>>>>>> like 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.


    idk why u keep repeatedly confirming the halting >>>>>>>>>>>>>>>>>>>>>> theorum, HHH cannot accurately decide on DD Efn+ >>>>>>>>>>>>>>>>>>>>>>

    You keep jumping ahead five steps before >>>>>>>>>>>>>>>>>>>>> I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while.

    idk why u like wasting so much time on running in >>>>>>>>>>>>>>>>>> circles with the rest of them. they don't even think >>>>>>>>>>>>>>>>>> something is broken, i do

    i'm just trying to get u focused in the right direction. >>>>>>>>>>>>>>>>>
    Your assumption that I am incorrect prevents >>>>>>>>>>>>>>>>> you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks >>>>>>>>>>>>>>>>>> ain't the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated >>>>>>>>>>>>>>>>> final state.**

    which doesn't prove anything about the nature of DD. HHH >>>>>>>>>>>>>>>> causes the end of DD's simulation, breaking the >>>>>>>>>>>>>>>> invariant that HHH not do that, as acknowledged by >>>>>>>>>>>>>>>> sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what happens >>>>>>>>>>>>>>> after
    simulation has been aborted or we would judge that all >>>>>>>>>>>>>>> infinite
    loops always halt. Instead we look for a repeating state >>>>>>>>>>>>>>> while the
    simulation continues.

    that is not a definition of the word "invariant"

    and this is just an inductive failure resulting from an >>>>>>>>>>>>>> overgeneralization fallacy polcott. not only does HHH need >>>>>>>>>>>>>> to prove that the recursion happens, HHH needs to prove >>>>>>>>>>>>>> that it continues to happen. one can't just prove the base >>>>>>>>>>>>>> case in an inductive proof, one needs to prove it for N+1 >>>>>>>>>>>>>> based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head


    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. i >>>>>>>>>> can't believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total >>>>>>>> halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting decider,
    and HHH demonstrates quite well by failing to compute DD's correct
    halting semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.

    polcott, it's a very reasonable to be concerned about computing/
    proving the true halting semantics of any given machine

    i'm not sure what ur disagreement is


    Math asks for the logically impossible and then

    the theory of computing is part of math

    blames computation when this request is not fulfilled.

    blame??? it's not blame, it's proof based on the idiosyncrasies of self-referential analysis


    When the request is properly framed as finite
    string transformation rules applied to finite
    string inputs then this request can be fulfilled.

    polcott, HHH(DD) returning 0 does not match the objective halting
    semantics of DD, which is that DD halts

    HHH(DD)->0 has not fulfilled the request of computing the objective
    halting semantics of DD





    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation works... >>>>>>

    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.








    --
    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 on Thu Nov 5 15:55:30 2026
    From Newsgroup: sci.logic

    On 11/5/2026 3:45 PM, dart200 wrote:
    On 11/5/26 1:37 PM, olcott wrote:
    On 11/5/2026 3:12 PM, dart200 wrote:
    On 11/5/26 1:06 PM, olcott wrote:
    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote:
    On 11/3/26 2:59 PM, olcott wrote:
    On 11/3/2026 4:56 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:33 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>>>> You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way consensus" >>>>>>>>>>>>>>>>>>>>>>>>> whenever someone challenges YOUR conclusions. >>>>>>>>>>>>>>>>>>>>>>>>>

    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with >>>>>>>>>>>>>>>>>>>>>>>> anythingr
    like 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.


    idk why u keep repeatedly confirming the halting >>>>>>>>>>>>>>>>>>>>>>> theorum, HHH cannot accurately decide on DD Efn+ >>>>>>>>>>>>>>>>>>>>>>>

    You keep jumping ahead five steps before >>>>>>>>>>>>>>>>>>>>>> I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while. >>>>>>>>>>>>>>>>>>>
    idk why u like wasting so much time on running in >>>>>>>>>>>>>>>>>>> circles with the rest of them. they don't even think >>>>>>>>>>>>>>>>>>> something is broken, i do

    i'm just trying to get u focused in the right direction. >>>>>>>>>>>>>>>>>>
    Your assumption that I am incorrect prevents >>>>>>>>>>>>>>>>>> you from understanding what I am saying.

    failing to acknowledge the invariant ur proof breaks >>>>>>>>>>>>>>>>>>> ain't the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own simulated >>>>>>>>>>>>>>>>>> final state.**

    which doesn't prove anything about the nature of DD. >>>>>>>>>>>>>>>>> HHH causes the end of DD's simulation, breaking the >>>>>>>>>>>>>>>>> invariant that HHH not do that, as acknowledged by >>>>>>>>>>>>>>>>> sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what >>>>>>>>>>>>>>>> happens after
    simulation has been aborted or we would judge that all >>>>>>>>>>>>>>>> infinite
    loops always halt. Instead we look for a repeating state >>>>>>>>>>>>>>>> while the
    simulation continues.

    that is not a definition of the word "invariant" >>>>>>>>>>>>>>>
    and this is just an inductive failure resulting from an >>>>>>>>>>>>>>> overgeneralization fallacy polcott. not only does HHH >>>>>>>>>>>>>>> need to prove that the recursion happens, HHH needs to >>>>>>>>>>>>>>> prove that it continues to happen. one can't just prove >>>>>>>>>>>>>>> the base case in an inductive proof, one needs to prove >>>>>>>>>>>>>>> it for N+1 based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head >>>>>>>>>>>>>

    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. >>>>>>>>>>> i can't believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs
    then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total >>>>>>>>> halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting decider,
    and HHH demonstrates quite well by failing to compute DD's correct
    halting semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.

    polcott, it's a very reasonable to be concerned about computing/
    proving the true halting semantics of any given machine

    i'm not sure what ur disagreement is


    Math asks for the logically impossible and then

    the theory of computing is part of math

    blames computation when this request is not fulfilled.

    blame??? it's not blame, it's proof based on the idiosyncrasies of self- referential analysis


    The math requirements of a halt decider are outside
    the scope of finite string transformation rules
    applied to finite string inputs in the same way as
    the requirements that your toaster to fill your
    tires with air are outside the scope of toasters.


    When the request is properly framed as finite
    string transformation rules applied to finite
    string inputs then this request can be fulfilled.

    polcott, HHH(DD) returning 0 does not match the objective halting
    semantics of DD, which is that DD halts

    HHH(DD)->0 has not fulfilled the request of computing the objective
    halting semantics of DD





    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation works... >>>>>>>

    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.









    --
    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 Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 14:01:20 2026
    From Newsgroup: sci.logic

    On 11/4/2026 1:40 PM, Chris M. Thomasson wrote:
    On 11/3/2026 12:29 AM, dart200 wrote:
    On 11/2/26 9:26 PM, olcott wrote:
    On 11/2/2026 11:08 PM, dart200 wrote:
    On 11/2/26 5:17 PM, olcott wrote:
    On 11/2/2026 7:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion. >>>>>>>>>>>>>>>>>>> Hypothesize this and I will prove it later: >>>>>>>>>>>>>>>>>>>
    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts >>>>>>>>>>>>>>>>>>

    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input. >>>>>>>>>>>>>>>>>
    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated >>>>>>>>>>>>>>>>> by HHH to determine the behavior specified by >>>>>>>>>>>>>>>>> the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the >>>>>>>>>>>>>>>> halting semantics of DD when simulated by universal >>>>>>>>>>>>>>>> simulator (EYon as defined by turing), which is the halting >>>>>>>>>>>>>>>> semantics we are interested in:

    <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 >>>>>>>>>>>>>>
    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted >>>>>>>>>>>>>

    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which >>>>>>>>> the conclusion rests upon a statement made by some presumed >>>>>>>>> authority or witness... Because the testimony of a qualified >>>>>>>>> authority or witness provides a reason for believing a claim, >>>>>>>>> such arguments are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated >>>>>>>> D would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_


    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct
    whatever follows the then is stipulated to be correct


    sipser himself only agreed that H is correct *unless DD is aborted
    then*

    ur actively ignoring the conditional on the proof, which is that H
    is correct if and only if D is then not aborted...

    HHH aborts DD's simulation, so therefore the analysis HHH makes
    prior to the abort is invalidated

    ur can write me off a useless troll all u want, but i'm still going
    to try to post helpful comments polcott. and i suggest that ignoring
    the conditional is a major flaw in what ur trying to propose atm


    Why the fuck do you add those two groups

    cause i'm hoping u'll actually take this seriously instead of running
    away again tbh???


    alt.buddha.short.fat.guy''

    tbh i kinda hate the dud cons that infest that group. i'm tryin to
    make them less stupid but ya know how trump loving types go eh??? walk
    around with their head up their asshole most of the day denying basic
    physical facts to confirm their endlessly narcissistic biases...

    alt.messianic

    just using it as a personal journal i guess??? Efn+Efn+Efn+


    Have you always only been a troll?



    You are smarter than him. Deal with it... ;^D
    .
    Sorry. There's nobody here right now to answer your questions or to post comments.

    We're not big on the existential and metaphysical theories. Over here,
    seeing is believing. If it doesn't add up, it's probably a hoax.

    So, I'm skeptical.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Dude@punditster@gmail.com to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 14:02:30 2026
    From Newsgroup: sci.logic

    On 11/4/2026 10:51 PM, dart200 wrote:
    On 11/2/26 9:16 PM, Chris M. Thomasson wrote:
    On 11/2/2026 5:14 PM, dart200 wrote:
    On 11/2/26 4:49 PM, olcott wrote:
    On 11/2/2026 6:02 PM, dart200 wrote:
    On 11/2/26 9:37 AM, olcott wrote:
    On 11/2/2026 11:18 AM, dart200 wrote:
    On 11/2/26 9:08 AM, olcott wrote:
    On 11/2/2026 10:59 AM, dart200 wrote:
    On 11/2/26 7:59 AM, olcott wrote:
    On 11/2/2026 9:38 AM, dart200 wrote:
    On 11/2/26 6:16 AM, olcott wrote:
    On 11/2/2026 2:32 AM, dart200 wrote:
    On 11/1/26 8:23 PM, olcott wrote:
    On 11/1/2026 10:06 PM, dart200 wrote:
    On 11/1/26 6:57 PM, olcott wrote:
    On 11/1/2026 8:31 PM, Python wrote:
    Oh, come on, Peter.

    There is nothing remotely mysterious here requiring >>>>>>>>>>>>>>>>> some uniquely profound understanding of the >>>>>>>>>>>>>>>>> "foundations of computation".


    You cannot correctly leap to that conclusion.
    Hypothesize this and I will prove it later:

    DD simulated by HHH is the only correct way to determine >>>>>>>>>>>>>>>> the semantic halting property of the input finite string >>>>>>>>>>>>>>>> of source code.


    HHH still doesn't actually determine was DD does >>>>>>>>>>>>>>>
    int main() {
    -a-a DD()-a-a-a-a-a-a-a // DD halts here
    }-a-a-a-a-a-a-a-a-a-a-a -a // main also halts


    If you would pay 100% complete attention
    you would see that computable functions
    are not allowed to do that.

    Computable functions are only allowed to
    report on whatever sequence of steps is
    directly encoded in the finite string input.

    DD simulated by HHH never halts.
    There exists no alternatives to DD simulated
    by HHH to determine the behavior specified by
    the input DD. Try and think of one.


    right, in no universe can HHH correctly decide the halting >>>>>>>>>>>>> semantics of DD when simulated by universal simulator (EYon as >>>>>>>>>>>>> defined by turing), which is the halting semantics we are >>>>>>>>>>>>> interested in:

    <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

    quoting sipser is not a proof polcott:


    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.


    Does entail (even if no one agrees)
    its simulated D would never stop running unless aborted


    right, but DD running forever is only a hypothetical.

    The ONLY point that I am making is the above point.
    Every other point is a mere distraction away from
    the above point.

    <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

    The above point almost completely proves that the
    requirements of the above paragraph have been met.

    u don't know what an argument from authority fallacy is?


    I know what that deductive fallacy is on the other hand

    "An argument from authority is an inductive argument in which the >>>>>> conclusion rests upon a statement made by some presumed authority >>>>>> or witness... Because the testimony of a qualified authority or
    witness provides a reason for believing a claim, such arguments
    are often inductively strong or cogent."

    key line from sipser: H correctly determines that its simulated D
    would never stop running _unless aborted then_


    <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

    What HHH does after verifying that the above paragraph
    conditions have been met is irrelevant. When these
    conditions have been met what follows them is stipulated
    to be correct.

    key phrase from sipser: ...unless aborted _then_

    the "then" refers to aborting after the recursion is detected. sipser
    provides an exception to the correctness of the decision, explicitly
    if the simulation is _then_ aborted after the determination is made.
    this is what HHH does, and therefore the analysis by HHH of DD is
    invalidated

    it sucks to be wrong polcott, but it's better to admit ur wrong than
    continue being wrong, this is know from experience


    Sage advice.

    could u ever have foreseen sage advice coming from me chris?

    You came here for sage advice?
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 16:50:17 2026
    From Newsgroup: sci.logic

    On 11/5/26 1:55 PM, olcott wrote:
    On 11/5/2026 3:45 PM, dart200 wrote:
    On 11/5/26 1:37 PM, olcott wrote:
    On 11/5/2026 3:12 PM, dart200 wrote:
    On 11/5/26 1:06 PM, olcott wrote:
    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote:
    On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:56 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:33 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way >>>>>>>>>>>>>>>>>>>>>>>>>> consensus" whenever someone challenges YOUR >>>>>>>>>>>>>>>>>>>>>>>>>> conclusions.


    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with >>>>>>>>>>>>>>>>>>>>>>>>> anythingr
    like 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.


    idk why u keep repeatedly confirming the halting >>>>>>>>>>>>>>>>>>>>>>>> theorum, HHH cannot accurately decide on DD Efn+ >>>>>>>>>>>>>>>>>>>>>>>>

    You keep jumping ahead five steps before >>>>>>>>>>>>>>>>>>>>>>> I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while. >>>>>>>>>>>>>>>>>>>>
    idk why u like wasting so much time on running in >>>>>>>>>>>>>>>>>>>> circles with the rest of them. they don't even think >>>>>>>>>>>>>>>>>>>> something is broken, i do

    i'm just trying to get u focused in the right >>>>>>>>>>>>>>>>>>>> direction.

    Your assumption that I am incorrect prevents >>>>>>>>>>>>>>>>>>> you from understanding what I am saying. >>>>>>>>>>>>>>>>>>>
    failing to acknowledge the invariant ur proof breaks >>>>>>>>>>>>>>>>>>>> ain't the right direction polcott


    **Simulation invariant**
    **DD simulated by HHH does not reach its own >>>>>>>>>>>>>>>>>>> simulated final state.**

    which doesn't prove anything about the nature of DD. >>>>>>>>>>>>>>>>>> HHH causes the end of DD's simulation, breaking the >>>>>>>>>>>>>>>>>> invariant that HHH not do that, as acknowledged by >>>>>>>>>>>>>>>>>> sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what >>>>>>>>>>>>>>>>> happens after
    simulation has been aborted or we would judge that all >>>>>>>>>>>>>>>>> infinite
    loops always halt. Instead we look for a repeating >>>>>>>>>>>>>>>>> state while the
    simulation continues.

    that is not a definition of the word "invariant" >>>>>>>>>>>>>>>>
    and this is just an inductive failure resulting from an >>>>>>>>>>>>>>>> overgeneralization fallacy polcott. not only does HHH >>>>>>>>>>>>>>>> need to prove that the recursion happens, HHH needs to >>>>>>>>>>>>>>>> prove that it continues to happen. one can't just prove >>>>>>>>>>>>>>>> the base case in an inductive proof, one needs to prove >>>>>>>>>>>>>>>> it for N+1 based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head >>>>>>>>>>>>>>

    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating machine. >>>>>>>>>>>> i can't believe we're still arguing about this


    If a computable function cannot be reduced to applying
    finite string transformations to its finite string inputs >>>>>>>>>>> then the computation of this function is outside of the
    scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total >>>>>>>>>> halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting decider, >>>>>> and HHH demonstrates quite well by failing to compute DD's correct >>>>>> halting semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.

    polcott, it's a very reasonable to be concerned about computing/
    proving the true halting semantics of any given machine

    i'm not sure what ur disagreement is


    Math asks for the logically impossible and then

    the theory of computing is part of math

    blames computation when this request is not fulfilled.

    blame??? it's not blame, it's proof based on the idiosyncrasies of
    self- referential analysis


    The math requirements of a halt decider are outside
    the scope of finite string transformation rules
    applied to finite string inputs

    yes, that is the halting theorem

    in the same way as
    the requirements that your toaster to fill your
    tires with air are outside the scope of toasters.

    i can't agree that an automated semantic decider is an absurd thing to
    desire



    When the request is properly framed as finite
    string transformation rules applied to finite
    string inputs then this request can be fulfilled.

    polcott, HHH(DD) returning 0 does not match the objective halting
    semantics of DD, which is that DD halts

    HHH(DD)->0 has not fulfilled the request of computing the objective
    halting semantics of DD





    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation works... >>>>>>>>

    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.











    --
    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 on Thu Nov 5 19:13:01 2026
    From Newsgroup: sci.logic

    On 11/5/2026 6:50 PM, dart200 wrote:
    On 11/5/26 1:55 PM, olcott wrote:
    On 11/5/2026 3:45 PM, dart200 wrote:
    On 11/5/26 1:37 PM, olcott wrote:
    On 11/5/2026 3:12 PM, dart200 wrote:
    On 11/5/26 1:06 PM, olcott wrote:
    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>> On 11/3/26 3:36 PM, olcott wrote:
    On 11/3/2026 5:32 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:56 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:33 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way >>>>>>>>>>>>>>>>>>>>>>>>>>> consensus" whenever someone challenges YOUR >>>>>>>>>>>>>>>>>>>>>>>>>>> conclusions.


    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with >>>>>>>>>>>>>>>>>>>>>>>>>> anythingr
    like 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.


    idk why u keep repeatedly confirming the >>>>>>>>>>>>>>>>>>>>>>>>> halting theorum, HHH cannot accurately decide >>>>>>>>>>>>>>>>>>>>>>>>> on DD Efn+


    You keep jumping ahead five steps before >>>>>>>>>>>>>>>>>>>>>>>> I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while. >>>>>>>>>>>>>>>>>>>>>
    idk why u like wasting so much time on running in >>>>>>>>>>>>>>>>>>>>> circles with the rest of them. they don't even >>>>>>>>>>>>>>>>>>>>> think something is broken, i do

    i'm just trying to get u focused in the right >>>>>>>>>>>>>>>>>>>>> direction.

    Your assumption that I am incorrect prevents >>>>>>>>>>>>>>>>>>>> you from understanding what I am saying. >>>>>>>>>>>>>>>>>>>>
    failing to acknowledge the invariant ur proof >>>>>>>>>>>>>>>>>>>>> breaks ain't the right direction polcott >>>>>>>>>>>>>>>>>>>>>

    **Simulation invariant**
    **DD simulated by HHH does not reach its own >>>>>>>>>>>>>>>>>>>> simulated final state.**

    which doesn't prove anything about the nature of DD. >>>>>>>>>>>>>>>>>>> HHH causes the end of DD's simulation, breaking the >>>>>>>>>>>>>>>>>>> invariant that HHH not do that, as acknowledged by >>>>>>>>>>>>>>>>>>> sipser as well

    what does invariant mean to you polcott?

    We cannot ever judge halting on the basis of what >>>>>>>>>>>>>>>>>> happens after
    simulation has been aborted or we would judge that all >>>>>>>>>>>>>>>>>> infinite
    loops always halt. Instead we look for a repeating >>>>>>>>>>>>>>>>>> state while the
    simulation continues.

    that is not a definition of the word "invariant" >>>>>>>>>>>>>>>>>
    and this is just an inductive failure resulting from an >>>>>>>>>>>>>>>>> overgeneralization fallacy polcott. not only does HHH >>>>>>>>>>>>>>>>> need to prove that the recursion happens, HHH needs to >>>>>>>>>>>>>>>>> prove that it continues to happen. one can't just prove >>>>>>>>>>>>>>>>> the base case in an inductive proof, one needs to prove >>>>>>>>>>>>>>>>> it for N+1 based on the premise of it for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head >>>>>>>>>>>>>>>

    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating >>>>>>>>>>>>> machine. i can't believe we're still arguing about this >>>>>>>>>>>>>

    If a computable function cannot be reduced to applying >>>>>>>>>>>> finite string transformations to its finite string inputs >>>>>>>>>>>> then the computation of this function is outside of the >>>>>>>>>>>> scope of Turing computable functions in the same way
    that filling your tires with air is outside the scope
    of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a total >>>>>>>>>>> halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting decider, >>>>>>> and HHH demonstrates quite well by failing to compute DD's
    correct halting semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.

    polcott, it's a very reasonable to be concerned about computing/
    proving the true halting semantics of any given machine

    i'm not sure what ur disagreement is


    Math asks for the logically impossible and then

    the theory of computing is part of math

    blames computation when this request is not fulfilled.

    blame??? it's not blame, it's proof based on the idiosyncrasies of
    self- referential analysis


    The math requirements of a halt decider are outside
    the scope of finite string transformation rules
    applied to finite string inputs

    yes, that is the halting theorem

    in the same way as
    the requirements that your toaster to fill your
    tires with air are outside the scope of toasters.

    i can't agree that an automated semantic decider is an absurd thing to desire


    When X is outside of the scope of Y
    then an automated semantic decider
    that derives results on any basis
    than applying finite string transformations
    to input finite strings is out of scope
    for [Turing equivalent computation] in the
    same way as requiring your toaster to fill your
    tires with air is out-of-scope for your toaster.



    When the request is properly framed as finite
    string transformation rules applied to finite
    string inputs then this request can be fulfilled.

    polcott, HHH(DD) returning 0 does not match the objective halting
    semantics of DD, which is that DD halts

    HHH(DD)->0 has not fulfilled the request of computing the objective
    halting semantics of DD





    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation
    works...


    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.












    --
    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 17:15:39 2026
    From Newsgroup: sci.logic

    On 11/5/26 5:13 PM, olcott wrote:
    On 11/5/2026 6:50 PM, dart200 wrote:
    On 11/5/26 1:55 PM, olcott wrote:
    On 11/5/2026 3:45 PM, dart200 wrote:
    On 11/5/26 1:37 PM, olcott wrote:
    On 11/5/2026 3:12 PM, dart200 wrote:
    On 11/5/26 1:06 PM, olcott wrote:
    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote:
    On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/3/26 3:36 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 5:32 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:56 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:33 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way >>>>>>>>>>>>>>>>>>>>>>>>>>>> consensus" whenever someone challenges YOUR >>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusions.


    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with >>>>>>>>>>>>>>>>>>>>>>>>>>> anythingr
    like 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.


    idk why u keep repeatedly confirming the >>>>>>>>>>>>>>>>>>>>>>>>>> halting theorum, HHH cannot accurately decide >>>>>>>>>>>>>>>>>>>>>>>>>> on DD Efn+


    You keep jumping ahead five steps before >>>>>>>>>>>>>>>>>>>>>>>>> I establish my basis.

    there's no basis here polcott


    OK I am done talking to you for a while. >>>>>>>>>>>>>>>>>>>>>>
    idk why u like wasting so much time on running in >>>>>>>>>>>>>>>>>>>>>> circles with the rest of them. they don't even >>>>>>>>>>>>>>>>>>>>>> think something is broken, i do

    i'm just trying to get u focused in the right >>>>>>>>>>>>>>>>>>>>>> direction.

    Your assumption that I am incorrect prevents >>>>>>>>>>>>>>>>>>>>> you from understanding what I am saying. >>>>>>>>>>>>>>>>>>>>>
    failing to acknowledge the invariant ur proof >>>>>>>>>>>>>>>>>>>>>> breaks ain't the right direction polcott >>>>>>>>>>>>>>>>>>>>>>

    **Simulation invariant**
    **DD simulated by HHH does not reach its own >>>>>>>>>>>>>>>>>>>>> simulated final state.**

    which doesn't prove anything about the nature of DD. >>>>>>>>>>>>>>>>>>>> HHH causes the end of DD's simulation, breaking the >>>>>>>>>>>>>>>>>>>> invariant that HHH not do that, as acknowledged by >>>>>>>>>>>>>>>>>>>> sipser as well

    what does invariant mean to you polcott? >>>>>>>>>>>>>>>>>>>
    We cannot ever judge halting on the basis of what >>>>>>>>>>>>>>>>>>> happens after
    simulation has been aborted or we would judge that >>>>>>>>>>>>>>>>>>> all infinite
    loops always halt. Instead we look for a repeating >>>>>>>>>>>>>>>>>>> state while the
    simulation continues.

    that is not a definition of the word "invariant" >>>>>>>>>>>>>>>>>>
    and this is just an inductive failure resulting from >>>>>>>>>>>>>>>>>> an overgeneralization fallacy polcott. not only does >>>>>>>>>>>>>>>>>> HHH need to prove that the recursion happens, HHH >>>>>>>>>>>>>>>>>> needs to prove that it continues to happen. one can't >>>>>>>>>>>>>>>>>> just prove the base case in an inductive proof, one >>>>>>>>>>>>>>>>>> needs to prove it for N+1 based on the premise of it >>>>>>>>>>>>>>>>>> for N


    I can't help it that this is over you head.

    u not proving the inductive case is not over my head >>>>>>>>>>>>>>>>

    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating >>>>>>>>>>>>>> machine. i can't believe we're still arguing about this >>>>>>>>>>>>>>

    If a computable function cannot be reduced to applying >>>>>>>>>>>>> finite string transformations to its finite string inputs >>>>>>>>>>>>> then the computation of this function is outside of the >>>>>>>>>>>>> scope of Turing computable functions in the same way >>>>>>>>>>>>> that filling your tires with air is outside the scope >>>>>>>>>>>>> of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a >>>>>>>>>>>> total halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem?


    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting
    decider, and HHH demonstrates quite well by failing to compute >>>>>>>> DD's correct halting semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.

    polcott, it's a very reasonable to be concerned about computing/
    proving the true halting semantics of any given machine

    i'm not sure what ur disagreement is


    Math asks for the logically impossible and then

    the theory of computing is part of math

    blames computation when this request is not fulfilled.

    blame??? it's not blame, it's proof based on the idiosyncrasies of
    self- referential analysis


    The math requirements of a halt decider are outside
    the scope of finite string transformation rules
    applied to finite string inputs

    yes, that is the halting theorem

    in the same way as
    the requirements that your toaster to fill your
    tires with air are outside the scope of toasters.

    i can't agree that an automated semantic decider is an absurd thing to
    desire


    When X is outside of the scope of Y
    then an automated semantic decider
    that derives results on any basis
    than applying finite string transformations
    to input finite strings is out of scope
    for [Turing equivalent computation] in the
    same way as requiring your toaster to fill your
    tires with air is out-of-scope for your toaster.

    or in other words: u agree with the halting theorem Efai




    When the request is properly framed as finite
    string transformation rules applied to finite
    string inputs then this request can be fulfilled.

    polcott, HHH(DD) returning 0 does not match the objective halting
    semantics of DD, which is that DD halts

    HHH(DD)->0 has not fulfilled the request of computing the objective
    halting semantics of DD





    It has always been a stupid mistake to base the
    limits of computation on what math wants instead
    of what computation is and how computation works.

    but the halting theorem is proven based on how computation >>>>>>>>>> works...


    counter-factual
    It only seems that way when some of the key details
    are ignored by abstracting them away.

    My HHH/DD leaves nothing to the imagination than
    can be the basis for misconceptions or false
    assumptions.














    --
    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 19:26:14 2026
    From Newsgroup: sci.logic

    On 11/5/2026 7:15 PM, dart200 wrote:
    On 11/5/26 5:13 PM, olcott wrote:
    On 11/5/2026 6:50 PM, dart200 wrote:
    On 11/5/26 1:55 PM, olcott wrote:
    On 11/5/2026 3:45 PM, dart200 wrote:
    On 11/5/26 1:37 PM, olcott wrote:
    On 11/5/2026 3:12 PM, dart200 wrote:
    On 11/5/26 1:06 PM, olcott wrote:
    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>> On 11/4/26 3:10 AM, olcott wrote:
    On 11/4/2026 12:49 AM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 3:36 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 5:32 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:56 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:33 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way >>>>>>>>>>>>>>>>>>>>>>>>>>>>> consensus" whenever someone challenges YOUR >>>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusions.


    You can look at the record on news.giganews.com >>>>>>>>>>>>>>>>>>>>>>>>>>>> where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with >>>>>>>>>>>>>>>>>>>>>>>>>>>> anythingr
    like 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.


    idk why u keep repeatedly confirming the >>>>>>>>>>>>>>>>>>>>>>>>>>> halting theorum, HHH cannot accurately decide >>>>>>>>>>>>>>>>>>>>>>>>>>> on DD Efn+


    You keep jumping ahead five steps before >>>>>>>>>>>>>>>>>>>>>>>>>> I establish my basis.

    there's no basis here polcott >>>>>>>>>>>>>>>>>>>>>>>>>

    OK I am done talking to you for a while. >>>>>>>>>>>>>>>>>>>>>>>
    idk why u like wasting so much time on running in >>>>>>>>>>>>>>>>>>>>>>> circles with the rest of them. they don't even >>>>>>>>>>>>>>>>>>>>>>> think something is broken, i do

    i'm just trying to get u focused in the right >>>>>>>>>>>>>>>>>>>>>>> direction.

    Your assumption that I am incorrect prevents >>>>>>>>>>>>>>>>>>>>>> you from understanding what I am saying. >>>>>>>>>>>>>>>>>>>>>>
    failing to acknowledge the invariant ur proof >>>>>>>>>>>>>>>>>>>>>>> breaks ain't the right direction polcott >>>>>>>>>>>>>>>>>>>>>>>

    **Simulation invariant**
    **DD simulated by HHH does not reach its own >>>>>>>>>>>>>>>>>>>>>> simulated final state.**

    which doesn't prove anything about the nature of >>>>>>>>>>>>>>>>>>>>> DD. HHH causes the end of DD's simulation, breaking >>>>>>>>>>>>>>>>>>>>> the invariant that HHH not do that, as acknowledged >>>>>>>>>>>>>>>>>>>>> by sipser as well

    what does invariant mean to you polcott? >>>>>>>>>>>>>>>>>>>>
    We cannot ever judge halting on the basis of what >>>>>>>>>>>>>>>>>>>> happens after
    simulation has been aborted or we would judge that >>>>>>>>>>>>>>>>>>>> all infinite
    loops always halt. Instead we look for a repeating >>>>>>>>>>>>>>>>>>>> state while the
    simulation continues.

    that is not a definition of the word "invariant" >>>>>>>>>>>>>>>>>>>
    and this is just an inductive failure resulting from >>>>>>>>>>>>>>>>>>> an overgeneralization fallacy polcott. not only does >>>>>>>>>>>>>>>>>>> HHH need to prove that the recursion happens, HHH >>>>>>>>>>>>>>>>>>> needs to prove that it continues to happen. one can't >>>>>>>>>>>>>>>>>>> just prove the base case in an inductive proof, one >>>>>>>>>>>>>>>>>>> needs to prove it for N+1 based on the premise of it >>>>>>>>>>>>>>>>>>> for N


    I can't help it that this is over you head. >>>>>>>>>>>>>>>>>
    u not proving the inductive case is not over my head >>>>>>>>>>>>>>>>>

    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating >>>>>>>>>>>>>>> machine. i can't believe we're still arguing about this >>>>>>>>>>>>>>>

    If a computable function cannot be reduced to applying >>>>>>>>>>>>>> finite string transformations to its finite string inputs >>>>>>>>>>>>>> then the computation of this function is outside of the >>>>>>>>>>>>>> scope of Turing computable functions in the same way >>>>>>>>>>>>>> that filling your tires with air is outside the scope >>>>>>>>>>>>>> of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a >>>>>>>>>>>>> total halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem? >>>>>>>>>>>

    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting
    decider, and HHH demonstrates quite well by failing to compute >>>>>>>>> DD's correct halting semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.

    polcott, it's a very reasonable to be concerned about computing/ >>>>>>> proving the true halting semantics of any given machine

    i'm not sure what ur disagreement is


    Math asks for the logically impossible and then

    the theory of computing is part of math

    blames computation when this request is not fulfilled.

    blame??? it's not blame, it's proof based on the idiosyncrasies of
    self- referential analysis


    The math requirements of a halt decider are outside
    the scope of finite string transformation rules
    applied to finite string inputs

    yes, that is the halting theorem

    in the same way as
    the requirements that your toaster to fill your
    tires with air are outside the scope of toasters.

    i can't agree that an automated semantic decider is an absurd thing
    to desire


    When X is outside of the scope of Y
    then an automated semantic decider
    that derives results on any basis
    than applying finite string transformations
    to input finite strings is out of scope
    for [Turing equivalent computation] in the
    same way as requiring your toaster to fill your
    tires with air is out-of-scope for your toaster.

    or in other words: u agree with the halting theorem Efai


    That a halt decider can't bake an actual real
    angel food cake using mathematical abstractions
    as its only ingredient is also a fundamental
    limit of reality.
    --
    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,alt.messianic,alt.buddha.short.fat.guy on Thu Nov 5 17:39:26 2026
    From Newsgroup: sci.logic

    On 11/5/26 5:26 PM, olcott wrote:
    On 11/5/2026 7:15 PM, dart200 wrote:
    On 11/5/26 5:13 PM, olcott wrote:
    On 11/5/2026 6:50 PM, dart200 wrote:
    On 11/5/26 1:55 PM, olcott wrote:
    On 11/5/2026 3:45 PM, dart200 wrote:
    On 11/5/26 1:37 PM, olcott wrote:
    On 11/5/2026 3:12 PM, dart200 wrote:
    On 11/5/26 1:06 PM, olcott wrote:
    On 11/5/2026 2:59 PM, dart200 wrote:
    On 11/5/26 12:21 PM, olcott wrote:
    On 11/5/2026 2:12 PM, dart200 wrote:
    On 11/5/26 11:08 AM, olcott wrote:
    On 11/5/2026 1:03 PM, dart200 wrote:
    On 11/5/26 9:57 AM, olcott wrote:
    On 11/5/2026 11:06 AM, dart200 wrote:
    On 11/5/26 8:32 AM, olcott wrote:
    On 11/5/2026 10:20 AM, dart200 wrote:
    On 11/5/26 3:55 AM, olcott wrote:
    On 11/5/2026 12:50 AM, dart200 wrote:
    On 11/4/26 9:39 AM, olcott wrote:
    On 11/4/2026 11:33 AM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/4/26 3:10 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/4/2026 12:49 AM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 3:36 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 5:32 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:59 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:56 PM, dart200 wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/26 2:40 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/3/2026 4:33 PM, Python wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You write:

    -a-a-a "Of course. I have never said otherwise." >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    BULLSHIT.

    You repeatedly invoke your "five-way >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> consensus" whenever someone challenges >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOUR conclusions.


    You can look at the record on >>>>>>>>>>>>>>>>>>>>>>>>>>>>> news.giganews.com
    where my posts go back to 2004 and see that no >>>>>>>>>>>>>>>>>>>>>>>>>>>>> one from comp.theory has every agreed with >>>>>>>>>>>>>>>>>>>>>>>>>>>>> anythingr
    like 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.


    idk why u keep repeatedly confirming the >>>>>>>>>>>>>>>>>>>>>>>>>>>> halting theorum, HHH cannot accurately >>>>>>>>>>>>>>>>>>>>>>>>>>>> decide on DD Efn+


    You keep jumping ahead five steps before >>>>>>>>>>>>>>>>>>>>>>>>>>> I establish my basis.

    there's no basis here polcott >>>>>>>>>>>>>>>>>>>>>>>>>>

    OK I am done talking to you for a while. >>>>>>>>>>>>>>>>>>>>>>>>
    idk why u like wasting so much time on running >>>>>>>>>>>>>>>>>>>>>>>> in circles with the rest of them. they don't >>>>>>>>>>>>>>>>>>>>>>>> even think something is broken, i do >>>>>>>>>>>>>>>>>>>>>>>>
    i'm just trying to get u focused in the right >>>>>>>>>>>>>>>>>>>>>>>> direction.

    Your assumption that I am incorrect prevents >>>>>>>>>>>>>>>>>>>>>>> you from understanding what I am saying. >>>>>>>>>>>>>>>>>>>>>>>
    failing to acknowledge the invariant ur proof >>>>>>>>>>>>>>>>>>>>>>>> breaks ain't the right direction polcott >>>>>>>>>>>>>>>>>>>>>>>>

    **Simulation invariant**
    **DD simulated by HHH does not reach its own >>>>>>>>>>>>>>>>>>>>>>> simulated final state.**

    which doesn't prove anything about the nature of >>>>>>>>>>>>>>>>>>>>>> DD. HHH causes the end of DD's simulation, >>>>>>>>>>>>>>>>>>>>>> breaking the invariant that HHH not do that, as >>>>>>>>>>>>>>>>>>>>>> acknowledged by sipser as well

    what does invariant mean to you polcott? >>>>>>>>>>>>>>>>>>>>>
    We cannot ever judge halting on the basis of what >>>>>>>>>>>>>>>>>>>>> happens after
    simulation has been aborted or we would judge that >>>>>>>>>>>>>>>>>>>>> all infinite
    loops always halt. Instead we look for a repeating >>>>>>>>>>>>>>>>>>>>> state while the
    simulation continues.

    that is not a definition of the word "invariant" >>>>>>>>>>>>>>>>>>>>
    and this is just an inductive failure resulting from >>>>>>>>>>>>>>>>>>>> an overgeneralization fallacy polcott. not only does >>>>>>>>>>>>>>>>>>>> HHH need to prove that the recursion happens, HHH >>>>>>>>>>>>>>>>>>>> needs to prove that it continues to happen. one >>>>>>>>>>>>>>>>>>>> can't just prove the base case in an inductive >>>>>>>>>>>>>>>>>>>> proof, one needs to prove it for N+1 based on the >>>>>>>>>>>>>>>>>>>> premise of it for N


    I can't help it that this is over you head. >>>>>>>>>>>>>>>>>>
    u not proving the inductive case is not over my head >>>>>>>>>>>>>>>>>>

    *This is what induction proves*
    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 this doesn't prove that DD is a non-terminating >>>>>>>>>>>>>>>> machine. i can't believe we're still arguing about this >>>>>>>>>>>>>>>>

    If a computable function cannot be reduced to applying >>>>>>>>>>>>>>> finite string transformations to its finite string inputs >>>>>>>>>>>>>>> then the computation of this function is outside of the >>>>>>>>>>>>>>> scope of Turing computable functions in the same way >>>>>>>>>>>>>>> that filling your tires with air is outside the scope >>>>>>>>>>>>>>> of your toaster.

    The behavior of int main(){ DD(); }
    cannot be possibly be specified as an input
    finite string HHH(DD)

    yes polcott, the halting theorem says u cannot define a >>>>>>>>>>>>>> total halting decider!


    As it turns out to actually be this is for the
    same reason that your toaster cannot fill your
    tires with air.

    so ur not actually disagreeing with the halting theorem? >>>>>>>>>>>>

    The halting theorem does correctly prove that
    your toaster cannot fill your tires with air.
    It does not understand that toasters are not
    supposed to fill tires with air.

    Math requires things that are outside of the
    scope of Turing computable functions in the
    same way that toasters will not fill your
    tires with air.

    i don't really get ur disagreement polcott

    "math" has proven that no machine can be a total halting
    decider, and HHH demonstrates quite well by failing to compute >>>>>>>>>> DD's correct halting semantics


    Right and math can equally prove that no Turing
    machine is a plate of spaghetti.

    polcott, it's a very reasonable to be concerned about computing/ >>>>>>>> proving the true halting semantics of any given machine

    i'm not sure what ur disagreement is


    Math asks for the logically impossible and then

    the theory of computing is part of math

    blames computation when this request is not fulfilled.

    blame??? it's not blame, it's proof based on the idiosyncrasies of >>>>>> self- referential analysis


    The math requirements of a halt decider are outside
    the scope of finite string transformation rules
    applied to finite string inputs

    yes, that is the halting theorem

    in the same way as
    the requirements that your toaster to fill your
    tires with air are outside the scope of toasters.

    i can't agree that an automated semantic decider is an absurd thing
    to desire


    When X is outside of the scope of Y
    then an automated semantic decider
    that derives results on any basis
    than applying finite string transformations
    to input finite strings is out of scope
    for [Turing equivalent computation] in the
    same way as requiring your toaster to fill your
    tires with air is out-of-scope for your toaster.

    or in other words: u agree with the halting theorem Efai


    That a halt decider can't bake an actual real
    angel food cake using mathematical abstractions
    as its only ingredient is also a fundamental
    limit of reality.


    well i guess we've gotten polcott to stage 3 of scientific acceptance:

    | It is true, but completely trivial and unimportant

    who's betting on him getting to stage 4?

    | I said it all along
    --
    why are we god?
    let's end war EfOa

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From =?UTF-8?B?QW5kcsOpIEcuIElzYWFr?=@agisaak@gm.invalid to comp.theory,sci.logic on Thu Nov 5 19:35:19 2026
    From Newsgroup: sci.logic

    On 2026-11-05 11:58, olcott wrote:
    On 11/3/2026 5:13 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:50, olcott wrote:

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

    Yes. *While* the simulation continues, DD does not reach its return
    instruction. That's because your HHH stops simulating (aborts) before
    DD reaches its return instruction;

    *A five-way consensus disagrees*
    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.

    AFAICT, your "five-way consensus" does not disagree with what I claim
    above, but rather agrees with a very narrow claim which you have made
    and which you have then misconstrued to count as agreement with a much stronger claim.

    *Thus you are a liar at this point*
    Add your agreement making this a 6-way consensus
    or I won't talk to you again.

    I can't simply agree with a statement which I have reservations about
    just because you demand it (or because some other people may have agreed
    to it). And given your propensity to misinterpret exactly what people
    have said I have an understandable reluctance to agree with you on any
    point that isn't well-formalized.

    If you want to stop talking to me, that's no skin off my back. You have largely ignored my actual substantive points anyways.

    Also, why are you repeating a response verbatim from a post from a day
    or two ago? There's really no need to post material more than once.

    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 on Thu Nov 5 20:55:02 2026
    From Newsgroup: sci.logic

    On 11/5/2026 8:35 PM, Andr|- G. Isaak wrote:
    On 2026-11-05 11:58, olcott wrote:
    On 11/3/2026 5:13 PM, Andr|- G. Isaak wrote:
    On 2026-11-03 12:50, olcott wrote:

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



    Yes. *While* the simulation continues, DD does not reach its return
    instruction. That's because your HHH stops simulating (aborts) before
    DD reaches its return instruction;

    IT IS NOT BECAUSE OF THIS
    IT IS NOT BECAUSE OF THIS
    IT IS NOT BECAUSE OF THIS
    IT IS NOT BECAUSE OF THIS
    IT IS NOT BECAUSE OF THIS


    *A five-way consensus disagrees*
    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.

    AFAICT, your "five-way consensus" does not disagree with what I claim
    above, but rather agrees with a very narrow claim which you have made
    and which you have then misconstrued to count as agreement with a much stronger claim.

    *Thus you are a liar at this point*
    Add your agreement making this a 6-way consensus
    or I won't talk to you again.

    I can't simply agree with a statement which I have reservations about
    just because you demand it (or because some other people may have agreed
    to it). And given your propensity to misinterpret exactly what people
    have said I have an understandable reluctance to agree with you on any
    point that isn't well-formalized.

    If you want to stop talking to me, that's no skin off my back. You have largely ignored my actual substantive points anyways.

    Also, why are you repeating a response verbatim from a post from a day
    or two ago? There's really no need to post material more than once.

    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