• int DD2()

    From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Thu Nov 12 00:02:59 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT correct? >>>>>>>
    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

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

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

    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does _not_
    halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
    of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated. HHH only actually demonstrates one step of recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott




    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Thu Nov 12 20:55:46 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/12/26 12:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT
    correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

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

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }

    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
    of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and classifying them the same

    how do u respond to this inconsistency polcott?

    polcott u still haven't responded to the fact HHH classifies both
    halting DD and non-halting DD2 into the same set of machines with the
    same semantic halting behavior...

    this is truly a 1 = 0 type of fault



    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial
    recursion is demonstrated. HHH only actually demonstrates one step of
    recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH
    does break that invariant, so invalidating the induction requires to
    prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott






    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 10:55:58 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/12/26 8:55 PM, dart200 wrote:
    On 11/12/26 12:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

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

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }

    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does
    _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is
    still not infinitely recursive it is actually just a simple non-
    terminating loop of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and
    classifying them the same

    how do u respond to this inconsistency polcott?

    polcott u still haven't responded to the fact HHH classifies both
    halting DD and non-halting DD2 into the same set of machines with the
    same semantic halting behavior...

    this is truly a 1 = 0 type of fault



    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated. HHH only actually demonstrates one
    step of recursion, not infinite. the infinite recursion only occurs
    if HHH doesn't break the invariant of letting the simulation run, but
    HHH does break that invariant, so invalidating the induction requires
    to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical" >>>>
    HHH violates the invariant so it violates it's own proof that DD is >>>>> recursive

    sipser said that same thing polcott








    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 13:03:24 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT
    correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being
    wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

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

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
    of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the recursion
    is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the initial
    recursion is demonstrated. HHH only actually demonstrates one step of
    recursion, not infinite. the infinite recursion only occurs if HHH
    doesn't break the invariant of letting the simulation run, but HHH
    does break that invariant, so invalidating the induction requires to
    prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical"

    HHH violates the invariant so it violates it's own proof that DD is
    recursive

    sipser said that same thing polcott






    --
    Copyright 2026 Olcott

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

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

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

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

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

    My 28 year goal has been to make
    "true on the basis of meaning expressed in language"
    reliably computable for the entire body of general knowledge.
    The complete structure of this system is now defined.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 11:51:48 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

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

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code and nowhere does it mention HHH1. seriously bro i
    have poured over ur comments before and u not giving me the same respect
    back for literally 7 lines of code, 6 of which is urs i only changed one
    for DD2...

    my comment is that DD and DD2 are both classified as having the same
    semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a
    non-halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
    the same decision to terminate and return 0, after which DD2 does
    _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is
    still not infinitely recursive it is actually just a simple non-
    terminating loop of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and
    classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based on
    the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated. HHH only actually demonstrates one
    step of recursion, not infinite. the infinite recursion only occurs
    if HHH doesn't break the invariant of letting the simulation run, but
    HHH does break that invariant, so invalidating the induction requires
    to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a hypothetical" >>>>
    HHH violates the invariant so it violates it's own proof that DD is >>>>> recursive

    sipser said that same thing polcott








    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 13:56:23 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

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

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    and nowhere does it mention HHH1. seriously bro i
    have poured over ur comments before and u not giving me the same respect back for literally 7 lines of code, 6 of which is urs i only changed one
    for DD2...

    my comment is that DD and DD2 are both classified as having the same semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a non- halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
    makes the same decision to terminate and return 0, after which DD2
    does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2
    is still not infinitely recursive it is actually just a simple non-
    terminating loop of one repeated state since that is the simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and
    classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated. HHH only actually demonstrates
    one step of recursion, not infinite. the infinite recursion only
    occurs if HHH doesn't break the invariant of letting the simulation
    run, but HHH does break that invariant, so invalidating the
    induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a
    hypothetical"

    HHH violates the invariant so it violates it's own proof that DD
    is recursive

    sipser said that same thing polcott









    --
    Copyright 2026 Olcott

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

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

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

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

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

    My 28 year goal has been to make
    "true on the basis of meaning expressed in language"
    reliably computable for the entire body of general knowledge.
    The complete structure of this system is now defined.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 12:12:46 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/13/26 11:56 AM, olcott wrote:
    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???


    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

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

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    these are not analogous situations:

    HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders

    HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider

    right now ur claiming that HHH correctly classified halting machine DD
    and non-halting machine DD2 into the same semantic set without
    justifying how or why this ought to be so... or even acknowledging that
    it does so


    -aand nowhere does it mention HHH1. seriously bro i have poured over ur
    comments before and u not giving me the same respect back for
    literally 7 lines of code, 6 of which is urs i only changed one for
    DD2...

    my comment is that DD and DD2 are both classified as having the same
    semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a
    non- halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
    makes the same decision to terminate and return 0, after which DD2
    does _not_ halt, unlike DD1 which _does_ halt... but in this case
    DD2 is still not infinitely recursive it is actually just a simple
    non- terminating loop of one repeated state since that is the
    simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and
    classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the
    invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based
    on the invariant that HHH not cut DD simulation's short after the
    initial recursion is demonstrated. HHH only actually demonstrates
    one step of recursion, not infinite. the infinite recursion only
    occurs if HHH doesn't break the invariant of letting the simulation >>>>> run, but HHH does break that invariant, so invalidating the
    induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a
    hypothetical"

    HHH violates the invariant so it violates it's own proof that DD >>>>>>> is recursive

    sipser said that same thing polcott











    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 14:19:14 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/13/2026 2:12 PM, dart200 wrote:
    On 11/13/26 11:56 AM, olcott wrote:
    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions
    in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>

    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

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

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    these are not analogous situations:

    HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders

    HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider

    right now ur claiming that HHH correctly classified halting machine DD
    and non-halting machine DD2 into the same semantic set without
    justifying how or why this ought to be so... or even acknowledging that
    it does so


    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.



    -aand nowhere does it mention HHH1. seriously bro i have poured over
    ur comments before and u not giving me the same respect back for
    literally 7 lines of code, 6 of which is urs i only changed one for
    DD2...

    my comment is that DD and DD2 are both classified as having the same
    semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a
    non- halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
    makes the same decision to terminate and return 0, after which DD2
    does _not_ halt, unlike DD1 which _does_ halt... but in this case
    DD2 is still not infinitely recursive it is actually just a simple
    non- terminating loop of one repeated state since that is the
    simplest loop

    ur "decider" is equating the binary semantic halting behaviors of
    machine terminating machine DD and non-terminating machine DD2, and >>>>> classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>> invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical based >>>>>> on the invariant that HHH not cut DD simulation's short after the >>>>>> initial recursion is demonstrated. HHH only actually demonstrates >>>>>> one step of recursion, not infinite. the infinite recursion only
    occurs if HHH doesn't break the invariant of letting the
    simulation run, but HHH does break that invariant, so invalidating >>>>>> the induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a
    hypothetical"

    HHH violates the invariant so it violates it's own proof that DD >>>>>>>> is recursive

    sipser said that same thing polcott













    --
    Copyright 2026 Olcott

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

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

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

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

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

    My 28 year goal has been to make
    "true on the basis of meaning expressed in language"
    reliably computable for the entire body of general knowledge.
    The complete structure of this system is now defined.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From dart200@user7160@newsgrouper.org.invalid to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 13:18:12 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/13/26 12:19 PM, olcott wrote:
    On 11/13/2026 2:12 PM, dart200 wrote:
    On 11/13/26 11:56 AM, olcott wrote:
    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are NOT >>>>>>>>>>>>> correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years.
    The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions >>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence.
    As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that
    I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon.

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

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    these are not analogous situations:

    HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders

    HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider

    right now ur claiming that HHH correctly classified halting machine DD
    and non-halting machine DD2 into the same semantic set without
    justifying how or why this ought to be so... or even acknowledging
    that it does so


    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.


    ok to clarify:

    HHH is _not_ a halting semantics decider,

    it's more of a "semantically grounded for halting semantics" decider?



    -aand nowhere does it mention HHH1. seriously bro i have poured over
    ur comments before and u not giving me the same respect back for
    literally 7 lines of code, 6 of which is urs i only changed one for
    DD2...

    my comment is that DD and DD2 are both classified as having the same
    semantic halting behavior by HHH,

    and that's clearly a fault as DD is a halting machine and DD2 is a
    non- halting machine


    HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
    makes the same decision to terminate and return 0, after which DD2 >>>>>> does _not_ halt, unlike DD1 which _does_ halt... but in this case >>>>>> DD2 is still not infinitely recursive it is actually just a simple >>>>>> non- terminating loop of one repeated state since that is the
    simplest loop

    ur "decider" is equating the binary semantic halting behaviors of >>>>>> machine terminating machine DD and non-terminating machine DD2,
    and classifying them the same

    how do u respond to this inconsistency polcott?


    The fact that in most of the last four years no
    one would affirm that DD simulated by HHH according
    to the operational semantics of the C programming
    language specifies recursive simulation does seems
    to indicate that most people here are dishonest.


    the recursive simulation is purely a hypothetical based on the >>>>>>>>> invariant that HHH not cut DD simulation's short after the
    recursion is demonstrated

    let me be abundantly clear polcott:

    the /infinite/ recursive simulation is purely a hypothetical
    based on the invariant that HHH not cut DD simulation's short
    after the initial recursion is demonstrated. HHH only actually
    demonstrates one step of recursion, not infinite. the infinite
    recursion only occurs if HHH doesn't break the invariant of
    letting the simulation run, but HHH does break that invariant, so >>>>>>> invalidating the induction requires to prove infinite recursion

    sipser said that same thing polcott



    You just contradicted yourself.
    "purely a hypothetical" means never happened at all
    "after the recursion is demonstrated" means not "purely a
    hypothetical"

    HHH violates the invariant so it violates it's own proof that >>>>>>>>> DD is recursive

    sipser said that same thing polcott














    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy,alt.buddha.short.fat.guy,alt.messianic on Fri Nov 13 15:31:22 2026
    From Newsgroup: alt.buddha.short.fat.guy

    On 11/13/2026 3:18 PM, dart200 wrote:
    On 11/13/26 12:19 PM, olcott wrote:
    On 11/13/2026 2:12 PM, dart200 wrote:
    On 11/13/26 11:56 AM, olcott wrote:
    On 11/13/2026 1:51 PM, dart200 wrote:
    On 11/13/26 11:03 AM, olcott wrote:
    On 11/12/2026 2:02 AM, dart200 wrote:
    On 11/11/26 11:16 PM, dart200 wrote:
    On 11/11/26 8:50 PM, olcott wrote:
    On 11/11/2026 10:10 PM, dart200 wrote:
    On 11/11/26 11:24 AM, olcott wrote:
    On 11/11/2026 1:11 PM, dart200 wrote:
    On 11/11/26 8:34 AM, olcott wrote:
    On 11/11/2026 9:45 AM, Python wrote:
    Peter,

    Then a reviewer having an honest dialogue
    that pays complete attention and makes no
    attempt to change the subject can confirm
    that I am correct very quickly.

    Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?

    If I was not correct then at least one person
    could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
    words to not conform to their false assumptions.

    I can very much better show that these assumptions
    are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.


    polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>

    I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
    about proving the tiny aspects of nuance of details of
    the error of the halting theorem.

    I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
    my work has simply been progressively refined such that
    I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
    01 int DD()
    02 {
    03-a-a int Halt_Status = HHH(DD);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a return Halt_Status;
    07 }

    01 int DD2()
    02 {
    03-a-a int Halt_Status = HHH(DD2);
    04-a-a if (Halt_Status)
    05-a-a-a-a HERE: goto HERE;
    06-a-a HERE2: goto HERE2;
    07 }


    I have already fully addressed this whole category
    of ideas already 500 times.

    HHH and HHH1 are identical except that DD calls
    HHH(DD) and does not call HHH1 at all.

    HHH(DD)==0 is correct and HHH1(DD)==1 is correct
    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.

    dud, what are you talking about???

    DD2 is 7 lines of code

    I am not going to address endless diversions from the point.
    Either you can understand how my HHH(DD) and HHH1(DD)
    already address your variation of the same idea or you
    fail to understand.

    these are not analogous situations:

    HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders

    HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider

    right now ur claiming that HHH correctly classified halting machine
    DD and non-halting machine DD2 into the same semantic set without
    justifying how or why this ought to be so... or even acknowledging
    that it does so


    The main thing that I have changed is that HHH
    implements its own unify_with_occurs_check().
    This means semantically ungrounded thus bad input
    instead of non-halting.


    ok to clarify:

    HHH is _not_ a halting semantics decider,

    it's more of a "semantically grounded for halting semantics" decider?


    HHH(DD)==0
    (I need to simplify my repository and go back to D/H)
    Means that DD does not halt relative to HHH or
    DD is semantically ill-formed thus bad input to HHH.

    ?- LP = not(true(LP)).
    LP = not(true(LP)).
    ?- unify_with_occurs_check(LP, not(true(LP))).
    false.

    That fits better under the same umbrella of how I
    generically handle all pathological self-reference.
    The Liar Paradox is proven to not be grounded in
    a truth value because it is semantically ill-formed.

    LP has the same infinitely recursive pattern as
    DD simulated by HHH. In both cases HHH and
    unify_with_occurs_check() see the pattern and
    cut it off.
    --
    Copyright 2026 Olcott

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

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

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

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

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

    My 28 year goal has been to make
    "true on the basis of meaning expressed in language"
    reliably computable for the entire body of general knowledge.
    The complete structure of this system is now defined.
    --- Synchronet 3.22a-Linux NewsLink 1.2