• Olcott is provably correct --- no one can correctly refute this

    From olcott@polcott333@gmail.com to comp.theory,comp.lang.c,comp.lang.c,comp.ai.philosophy on Fri Oct 30 22:54:38 2026
    From Newsgroup: comp.ai.philosophy

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

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD()

    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    --
    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,comp.lang.c,comp.lang.c,comp.ai.philosophy on Fri Oct 30 20:59:30 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD()

    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated DD
    resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does _not_
    interfere with the simulation being run, like a turing machine itself
    does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. it's only reporting on a truncated partial trace of DD, not the full execution of DD
    --
    arising us out of the computing dark ages,
    please excuse my pseudo-pyscript,
    ~ the lil crank that could
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,comp.lang.c,comp.lang.c,comp.ai.philosophy on Fri Oct 30 23:26:14 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD()

    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated DD
    resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does _not_ interfere with the simulation being run, like a turing machine itself
    does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. it's only reporting on a truncated partial trace of DD, not the full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT
    --
    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,comp.lang.c,comp.lang.c,comp.ai.philosophy on Sat Oct 31 00:52:54 2026
    From Newsgroup: comp.ai.philosophy

    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD()

    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated DD
    resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does _not_
    interfere with the simulation being run, like a turing machine itself
    does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. it's
    only reporting on a truncated partial trace of DD, not the full
    execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in total.
    HHH cuts off the simulation of DD short, so ofc it doesn't reach DD's
    return statement

    asking for a rebuttal to explain how HHH simulating DD reaches DDs
    return statement is just ... nonsense. HHH is _not_ a universal
    simulator and does _not_ simulate DD in total nor even is expected to do so!

    it is therefore _not_ actually reporting on a complete simulation of DD, objectively so as HHH cuts off DDs simulation before DD reaches it's
    final state. if u compared the states the HHH(DD) records in it's
    simulation, this would not match the states that EYon(DD) records in it's simulation. HHH(DD) would match up to some point, at which point HHH(DD)
    would record no more states, while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the halting
    theorem in the slightest. i don't even think it's a total algorithm
    cause who tf knows what HHH(collatz_conj) would return, if even. i bet
    it wouldn't, i bet HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped reading by now
    tbh ... but you wanna know what i think is useful about this issue of
    HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite looping recursion like what it tries on DD, because that's how the inductive
    math proofs work. but u can't actually build a machine that totally
    implements that as an automated prover precisely because of the machine
    DD that u wrote...

    something feels off about that for sure, if the math was good HHH should
    work cause the algo is so dead simple.
    --
    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,comp.lang.c,comp.lang.c,comp.ai.philosophy on Sat Oct 31 06:58:57 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD()

    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated DD
    resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does _not_
    interfere with the simulation being run, like a turing machine itself
    does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. it's
    only reporting on a truncated partial trace of DD, not the full
    execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    HHH cuts off the simulation of DD short, so ofc it doesn't reach DD's
    return statement

    asking for a rebuttal to explain how HHH simulating DD reaches DDs
    return statement is just ... nonsense. HHH is _not_ a universal
    simulator and does _not_ simulate DD in total nor even is expected to do
    so!

    it is therefore _not_ actually reporting on a complete simulation of DD, objectively so as HHH cuts off DDs simulation before DD reaches it's
    final state. if u compared the states the HHH(DD) records in it's simulation, this would not match the states that EYon(DD) records in it's simulation. HHH(DD) would match up to some point, at which point HHH(DD) would record no more states, while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the halting
    theorem in the slightest. i don't even think it's a total algorithm
    cause who tf knows what HHH(collatz_conj) would return, if even. i bet
    it wouldn't, i bet HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped reading by now
    tbh ... but you wanna know what i think is useful about this issue of
    HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite looping recursion like what it tries on DD, because that's how the inductive
    math proofs work. but u can't actually build a machine that totally implements that as an automated prover precisely because of the machine
    DD that u wrote...

    something feels off about that for sure, if the math was good HHH should work cause the algo is so dead simple.

    --
    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,comp.lang.c,comp.lang.c,comp.ai.philosophy on Sat Oct 31 08:20:57 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD() >>>>>
    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated DD
    resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does _not_
    interfere with the simulation being run, like a turing machine
    itself does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. it's
    only reporting on a truncated partial trace of DD, not the full
    execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap on me


    HHH cuts off the simulation of DD short, so ofc it doesn't reach DD's
    return statement

    asking for a rebuttal to explain how HHH simulating DD reaches DDs
    return statement is just ... nonsense. HHH is _not_ a universal
    simulator and does _not_ simulate DD in total nor even is expected to
    do so!

    it is therefore _not_ actually reporting on a complete simulation of
    DD, objectively so as HHH cuts off DDs simulation before DD reaches
    it's final state. if u compared the states the HHH(DD) records in it's
    simulation, this would not match the states that EYon(DD) records in it's >> simulation. HHH(DD) would match up to some point, at which point
    HHH(DD) would record no more states, while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the halting
    theorem in the slightest. i don't even think it's a total algorithm
    cause who tf knows what HHH(collatz_conj) would return, if even. i bet
    it wouldn't, i bet HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped reading by
    now tbh ... but you wanna know what i think is useful about this issue
    of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite looping
    recursion like what it tries on DD, because that's how the inductive
    math proofs work. but u can't actually build a machine that totally
    implements that as an automated prover precisely because of the
    machine DD that u wrote...

    something feels off about that for sure, if the math was good HHH
    should work cause the algo is so dead simple.


    --
    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,comp.lang.c,comp.lang.c,comp.ai.philosophy on Sat Oct 31 10:25:44 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD() >>>>>>
    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated DD
    resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does _not_ >>>>> interfere with the simulation being run, like a turing machine
    itself does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. it's
    only reporting on a truncated partial trace of DD, not the full
    execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in total. >>
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH


    HHH cuts off the simulation of DD short, so ofc it doesn't reach DD's
    return statement

    asking for a rebuttal to explain how HHH simulating DD reaches DDs
    return statement is just ... nonsense. HHH is _not_ a universal
    simulator and does _not_ simulate DD in total nor even is expected to
    do so!

    it is therefore _not_ actually reporting on a complete simulation of
    DD, objectively so as HHH cuts off DDs simulation before DD reaches
    it's final state. if u compared the states the HHH(DD) records in
    it's simulation, this would not match the states that EYon(DD) records
    in it's simulation. HHH(DD) would match up to some point, at which
    point HHH(DD) would record no more states, while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the halting
    theorem in the slightest. i don't even think it's a total algorithm
    cause who tf knows what HHH(collatz_conj) would return, if even. i
    bet it wouldn't, i bet HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped reading by
    now tbh ... but you wanna know what i think is useful about this
    issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite
    looping recursion like what it tries on DD, because that's how the
    inductive math proofs work. but u can't actually build a machine that
    totally implements that as an automated prover precisely because of
    the machine DD that u wrote...

    something feels off about that for sure, if the math was good HHH
    should work cause the algo is so dead simple.



    --
    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,comp.lang.c,comp.lang.c,comp.ai.philosophy on Sat Oct 31 08:36:34 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that simulates >>>>>>> DD()

    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated DD >>>>>> resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does _not_ >>>>>> interfere with the simulation being run, like a turing machine
    itself does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. it's >>>>>> only reporting on a truncated partial trace of DD, not the full
    execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory):
    line 01: simulated olcott() invokes all-caps macro repeating line 01

    looks like your own brain just entered the infinite recursion you
    claimed HHH could detect. too bad HHH didn't abort before line 5.



    HHH cuts off the simulation of DD short, so ofc it doesn't reach
    DD's return statement

    asking for a rebuttal to explain how HHH simulating DD reaches DDs
    return statement is just ... nonsense. HHH is _not_ a universal
    simulator and does _not_ simulate DD in total nor even is expected
    to do so!

    it is therefore _not_ actually reporting on a complete simulation of
    DD, objectively so as HHH cuts off DDs simulation before DD reaches
    it's final state. if u compared the states the HHH(DD) records in
    it's simulation, this would not match the states that EYon(DD) records >>>> in it's simulation. HHH(DD) would match up to some point, at which
    point HHH(DD) would record no more states, while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the halting
    theorem in the slightest. i don't even think it's a total algorithm
    cause who tf knows what HHH(collatz_conj) would return, if even. i
    bet it wouldn't, i bet HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped reading by
    now tbh ... but you wanna know what i think is useful about this
    issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite
    looping recursion like what it tries on DD, because that's how the
    inductive math proofs work. but u can't actually build a machine
    that totally implements that as an automated prover precisely
    because of the machine DD that u wrote...

    something feels off about that for sure, if the math was good HHH
    should work cause the algo is so dead simple.





    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 10:42:17 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that simulates >>>>>>>> DD()

    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated DD >>>>>>> resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does _not_ >>>>>>> interfere with the simulation being run, like a turing machine
    itself does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator.
    it's only reporting on a truncated partial trace of DD, not the >>>>>>> full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in >>>>> total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory):
    line 01: simulated olcott() invokes all-caps macro repeating line 01

    looks like your own brain just entered the infinite recursion you
    claimed HHH could detect. too bad HHH didn't abort before line 5.


    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.



    HHH cuts off the simulation of DD short, so ofc it doesn't reach
    DD's return statement

    asking for a rebuttal to explain how HHH simulating DD reaches DDs
    return statement is just ... nonsense. HHH is _not_ a universal
    simulator and does _not_ simulate DD in total nor even is expected
    to do so!

    it is therefore _not_ actually reporting on a complete simulation
    of DD, objectively so as HHH cuts off DDs simulation before DD
    reaches it's final state. if u compared the states the HHH(DD)
    records in it's simulation, this would not match the states that
    EYon(DD) records in it's simulation. HHH(DD) would match up to some >>>>> point, at which point HHH(DD) would record no more states, while
    EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the halting
    theorem in the slightest. i don't even think it's a total algorithm >>>>> cause who tf knows what HHH(collatz_conj) would return, if even. i
    bet it wouldn't, i bet HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped reading by >>>>> now tbh ... but you wanna know what i think is useful about this
    issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite
    looping recursion like what it tries on DD, because that's how the
    inductive math proofs work. but u can't actually build a machine
    that totally implements that as an automated prover precisely
    because of the machine DD that u wrote...

    something feels off about that for sure, if the math was good HHH
    should work cause the algo is so dead simple.







    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 08:52:32 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that
    simulates DD()

    DD simulated by HHH according to the operational semantics
    of the C programming language cannot possibly reach its own
    simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated >>>>>>>> DD resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does >>>>>>>> _not_ interfere with the simulation being run, like a turing
    machine itself does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. >>>>>>>> it's only reporting on a truncated partial trace of DD, not the >>>>>>>> full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in >>>>>> total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap on me >>>>

    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory):
    line 01: simulated olcott() invokes all-caps macro repeating line 01

    looks like your own brain just entered the infinite recursion you
    claimed HHH could detect. too bad HHH didn't abort before line 5.


    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of
    professional experience


    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much bigger
    reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the courtesy of
    reading all that i wrote, and that really is ur loss because i'm most definitely not like the other chucklefucks around here




    HHH cuts off the simulation of DD short, so ofc it doesn't reach
    DD's return statement

    asking for a rebuttal to explain how HHH simulating DD reaches DDs >>>>>> return statement is just ... nonsense. HHH is _not_ a universal
    simulator and does _not_ simulate DD in total nor even is expected >>>>>> to do so!

    it is therefore _not_ actually reporting on a complete simulation >>>>>> of DD, objectively so as HHH cuts off DDs simulation before DD
    reaches it's final state. if u compared the states the HHH(DD)
    records in it's simulation, this would not match the states that
    EYon(DD) records in it's simulation. HHH(DD) would match up to some >>>>>> point, at which point HHH(DD) would record no more states, while
    EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the halting >>>>>> theorem in the slightest. i don't even think it's a total
    algorithm cause who tf knows what HHH(collatz_conj) would return, >>>>>> if even. i bet it wouldn't, i bet HHH(collatz_conj) diverges as
    written.

    now idk if ur gunna accept that or not, prolly u stopped reading
    by now tbh ... but you wanna know what i think is useful about
    this issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite
    looping recursion like what it tries on DD, because that's how the >>>>>> inductive math proofs work. but u can't actually build a machine
    that totally implements that as an automated prover precisely
    because of the machine DD that u wrote...

    something feels off about that for sure, if the math was good HHH >>>>>> should work cause the algo is so dead simple.









    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 11:31:35 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 10:52 AM, dart200 wrote:
    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that
    simulates DD()

    DD simulated by HHH according to the operational semantics >>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>> simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated >>>>>>>>> DD resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does >>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>> machine itself does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. >>>>>>>>> it's only reporting on a truncated partial trace of DD, not the >>>>>>>>> full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in >>>>>>> total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap on me >>>>>

    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory):
    line 01: simulated olcott() invokes all-caps macro repeating line 01

    looks like your own brain just entered the infinite recursion you
    claimed HHH could detect. too bad HHH didn't abort before line 5.


    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of
    professional experience


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

    Then I do not see why that you cannot see that
    while DD is simulated by HHH you will not concede
    that this same DD simulated by HHH will not reach
    its own line 06, unless your primary goal is to
    be disagreeable.

    If you fail to concede that DD simulated by HHH
    cannot reach its own line 06 while DD is being
    simulated by HHH

    or fail to show exactly how DD simulated by HHH
    does reach it own simulated line 06 while DD is
    being simulated by HHH I will end this conversation
    with you.



    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much bigger
    reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the courtesy of
    reading all that i wrote, and that really is ur loss because i'm most definitely not like the other chucklefucks around here




    HHH cuts off the simulation of DD short, so ofc it doesn't reach >>>>>>> DD's return statement

    asking for a rebuttal to explain how HHH simulating DD reaches
    DDs return statement is just ... nonsense. HHH is _not_ a
    universal simulator and does _not_ simulate DD in total nor even >>>>>>> is expected to do so!

    it is therefore _not_ actually reporting on a complete simulation >>>>>>> of DD, objectively so as HHH cuts off DDs simulation before DD
    reaches it's final state. if u compared the states the HHH(DD)
    records in it's simulation, this would not match the states that >>>>>>> EYon(DD) records in it's simulation. HHH(DD) would match up to some >>>>>>> point, at which point HHH(DD) would record no more states, while >>>>>>> EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the halting >>>>>>> theorem in the slightest. i don't even think it's a total
    algorithm cause who tf knows what HHH(collatz_conj) would return, >>>>>>> if even. i bet it wouldn't, i bet HHH(collatz_conj) diverges as >>>>>>> written.

    now idk if ur gunna accept that or not, prolly u stopped reading >>>>>>> by now tbh ... but you wanna know what i think is useful about
    this issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite
    looping recursion like what it tries on DD, because that's how
    the inductive math proofs work. but u can't actually build a
    machine that totally implements that as an automated prover
    precisely because of the machine DD that u wrote...

    something feels off about that for sure, if the math was good HHH >>>>>>> should work cause the algo is so dead simple.











    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 12:01:00 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 10:52 AM, dart200 wrote:
    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that
    simulates DD()

    DD simulated by HHH according to the operational semantics >>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>> simulated return statement while being simulated by HHH.

    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated >>>>>>>>> DD resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does >>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>> machine itself does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. >>>>>>>>> it's only reporting on a truncated partial trace of DD, not the >>>>>>>>> full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in >>>>>>> total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap on me >>>>>

    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory):
    line 01: simulated olcott() invokes all-caps macro repeating line 01

    looks like your own brain just entered the infinite recursion you
    claimed HHH could detect. too bad HHH didn't abort before line 5.


    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of
    professional experience


    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much bigger
    reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the courtesy of
    reading all that i wrote, and that really is ur loss because i'm most definitely not like the other chucklefucks around here


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

    Changing the subject away from the behavior of DD
    simulated by HHH while DD is being simulated by HHH
    ONE-MORE-TIME ENDS THIS CONVERSATION
    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 10:33:29 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/26 9:31 AM, olcott wrote:
    On 10/31/2026 10:52 AM, dart200 wrote:
    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that
    simulates DD()

    DD simulated by HHH according to the operational semantics >>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>
    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the simulated >>>>>>>>>> DD resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does >>>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>>> machine itself does not interfere with it's own execution

    HHH does interfere, therefore it's not a universal simulator. >>>>>>>>>> it's only reporting on a truncated partial trace of DD, not >>>>>>>>>> the full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD in >>>>>>>> total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap
    on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory):
    line 01: simulated olcott() invokes all-caps macro repeating line 01

    looks like your own brain just entered the infinite recursion you
    claimed HHH could detect. too bad HHH didn't abort before line 5.


    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of
    professional experience


    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 }

    Then I do not see why that you cannot see that
    while DD is simulated by HHH you will not concede
    that this same DD simulated by HHH will not reach

    i've already conceded HHH(DD) does not simulate DD to line 06: HHH(DD)
    does a partial simulation of DD, and therefor will not simulate DD to
    line 06

    its own line 06, unless your primary goal is to
    be disagreeable.

    i'm agreeing with u polcott on that point, why are you being so
    disagreeable about it? Efn+

    If you fail to concede that DD simulated by HHH
    cannot reach its own line 06 while DD is being
    simulated by HHH

    or fail to show exactly how DD simulated by HHH
    does reach it own simulated line 06 while DD is
    being simulated by HHH I will end this conversation
    with you.

    let's suppose i could show that HHH(DD) simulating DD reaches line 06 in
    the simulation ... how would that refute ur proof?




    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much bigger
    reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the courtesy of
    reading all that i wrote, and that really is ur loss because i'm most
    definitely not like the other chucklefucks around here




    HHH cuts off the simulation of DD short, so ofc it doesn't reach >>>>>>>> DD's return statement

    asking for a rebuttal to explain how HHH simulating DD reaches >>>>>>>> DDs return statement is just ... nonsense. HHH is _not_ a
    universal simulator and does _not_ simulate DD in total nor even >>>>>>>> is expected to do so!

    it is therefore _not_ actually reporting on a complete
    simulation of DD, objectively so as HHH cuts off DDs simulation >>>>>>>> before DD reaches it's final state. if u compared the states the >>>>>>>> HHH(DD) records in it's simulation, this would not match the
    states that EYon(DD) records in it's simulation. HHH(DD) would >>>>>>>> match up to some point, at which point HHH(DD) would record no >>>>>>>> more states, while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the
    halting theorem in the slightest. i don't even think it's a
    total algorithm cause who tf knows what HHH(collatz_conj) would >>>>>>>> return, if even. i bet it wouldn't, i bet HHH(collatz_conj)
    diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped reading >>>>>>>> by now tbh ... but you wanna know what i think is useful about >>>>>>>> this issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite >>>>>>>> looping recursion like what it tries on DD, because that's how >>>>>>>> the inductive math proofs work. but u can't actually build a
    machine that totally implements that as an automated prover
    precisely because of the machine DD that u wrote...

    something feels off about that for sure, if the math was good >>>>>>>> HHH should work cause the algo is so dead simple.













    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 12:55:26 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 12:33 PM, dart200 wrote:
    On 10/31/26 9:31 AM, olcott wrote:
    On 10/31/2026 10:52 AM, dart200 wrote:
    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>> simulates DD()

    DD simulated by HHH according to the operational semantics >>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>
    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the
    simulated DD resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does >>>>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>>>> machine itself does not interfere with it's own execution >>>>>>>>>>>
    HHH does interfere, therefore it's not a universal simulator. >>>>>>>>>>> it's only reporting on a truncated partial trace of DD, not >>>>>>>>>>> the full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT


    HHH is not EYon the universal simulator and does not simulate DD >>>>>>>>> in total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap >>>>>>> on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory):
    line 01: simulated olcott() invokes all-caps macro repeating line 01 >>>>>
    looks like your own brain just entered the infinite recursion you
    claimed HHH could detect. too bad HHH didn't abort before line 5.


    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of
    professional experience


    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 }

    Then I do not see why that you cannot see that
    while DD is simulated by HHH you will not concede
    that this same DD simulated by HHH will not reach

    i've already conceded HHH(DD) does not simulate DD to line 06: HHH(DD)
    does a partial simulation of DD, and therefor will not simulate DD to
    line 06

    its own line 06, unless your primary goal is to
    be disagreeable.

    i'm agreeing with u polcott on that point, why are you being so
    disagreeable about it? Efn+

    If you fail to concede that DD simulated by HHH
    cannot reach its own line 06 while DD is being
    simulated by HHH

    or fail to show exactly how DD simulated by HHH
    does reach it own simulated line 06 while DD is
    being simulated by HHH I will end this conversation
    with you.

    let's suppose i could show that HHH(DD) simulating DD reaches line 06 in
    the simulation ... how would that refute ur proof?


    With the credentials that you say that you have you
    would already know it is a logical impossibility.




    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much bigger
    reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the courtesy of
    reading all that i wrote, and that really is ur loss because i'm most
    definitely not like the other chucklefucks around here




    HHH cuts off the simulation of DD short, so ofc it doesn't
    reach DD's return statement

    asking for a rebuttal to explain how HHH simulating DD reaches >>>>>>>>> DDs return statement is just ... nonsense. HHH is _not_ a
    universal simulator and does _not_ simulate DD in total nor >>>>>>>>> even is expected to do so!

    it is therefore _not_ actually reporting on a complete
    simulation of DD, objectively so as HHH cuts off DDs simulation >>>>>>>>> before DD reaches it's final state. if u compared the states >>>>>>>>> the HHH(DD) records in it's simulation, this would not match >>>>>>>>> the states that EYon(DD) records in it's simulation. HHH(DD) would >>>>>>>>> match up to some point, at which point HHH(DD) would record no >>>>>>>>> more states, while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the
    halting theorem in the slightest. i don't even think it's a >>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) would >>>>>>>>> return, if even. i bet it wouldn't, i bet HHH(collatz_conj) >>>>>>>>> diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped
    reading by now tbh ... but you wanna know what i think is
    useful about this issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite >>>>>>>>> looping recursion like what it tries on DD, because that's how >>>>>>>>> the inductive math proofs work. but u can't actually build a >>>>>>>>> machine that totally implements that as an automated prover >>>>>>>>> precisely because of the machine DD that u wrote...

    something feels off about that for sure, if the math was good >>>>>>>>> HHH should work cause the algo is so dead simple.















    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 11:06:51 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/26 10:55 AM, olcott wrote:
    On 10/31/2026 12:33 PM, dart200 wrote:
    On 10/31/26 9:31 AM, olcott wrote:
    On 10/31/2026 10:52 AM, dart200 wrote:
    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH)
    Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>> simulates DD()

    DD simulated by HHH according to the operational semantics >>>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>>
    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the
    simulated DD resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does >>>>>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>>>>> machine itself does not interfere with it's own execution >>>>>>>>>>>>
    HHH does interfere, therefore it's not a universal
    simulator. it's only reporting on a truncated partial trace >>>>>>>>>>>> of DD, not the full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>

    HHH is not EYon the universal simulator and does not simulate DD >>>>>>>>>> in total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot crap >>>>>>>> on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory):
    line 01: simulated olcott() invokes all-caps macro repeating line 01 >>>>>>
    looks like your own brain just entered the infinite recursion you
    claimed HHH could detect. too bad HHH didn't abort before line 5.


    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of
    professional experience


    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 }

    Then I do not see why that you cannot see that
    while DD is simulated by HHH you will not concede
    that this same DD simulated by HHH will not reach

    i've already conceded HHH(DD) does not simulate DD to line 06: HHH(DD)
    does a partial simulation of DD, and therefor will not simulate DD to
    line 06

    its own line 06, unless your primary goal is to
    be disagreeable.

    i'm agreeing with u polcott on that point, why are you being so
    disagreeable about it? Efn+

    If you fail to concede that DD simulated by HHH
    cannot reach its own line 06 while DD is being
    simulated by HHH

    or fail to show exactly how DD simulated by HHH
    does reach it own simulated line 06 while DD is
    being simulated by HHH I will end this conversation
    with you.

    let's suppose i could show that HHH(DD) simulating DD reaches line 06
    in the simulation ... how would that refute ur proof?


    With the credentials that you say that you have you
    would already know it is a logical impossibility.

    the only rebuttal u'll accept is in fact a logical impossibility?

    so u were just outright lying to me when u said such would be the only acceptable rebuttal... because it's _not_ an acceptable rebuttal





    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much bigger
    reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the courtesy of
    reading all that i wrote, and that really is ur loss because i'm
    most definitely not like the other chucklefucks around here




    HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>> reach DD's return statement

    asking for a rebuttal to explain how HHH simulating DD reaches >>>>>>>>>> DDs return statement is just ... nonsense. HHH is _not_ a >>>>>>>>>> universal simulator and does _not_ simulate DD in total nor >>>>>>>>>> even is expected to do so!

    it is therefore _not_ actually reporting on a complete
    simulation of DD, objectively so as HHH cuts off DDs
    simulation before DD reaches it's final state. if u compared >>>>>>>>>> the states the HHH(DD) records in it's simulation, this would >>>>>>>>>> not match the states that EYon(DD) records in it's simulation. >>>>>>>>>> HHH(DD) would match up to some point, at which point HHH(DD) >>>>>>>>>> would record no more states, while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the >>>>>>>>>> halting theorem in the slightest. i don't even think it's a >>>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) >>>>>>>>>> would return, if even. i bet it wouldn't, i bet
    HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped
    reading by now tbh ... but you wanna know what i think is >>>>>>>>>> useful about this issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an infinite >>>>>>>>>> looping recursion like what it tries on DD, because that's how >>>>>>>>>> the inductive math proofs work. but u can't actually build a >>>>>>>>>> machine that totally implements that as an automated prover >>>>>>>>>> precisely because of the machine DD that u wrote...

    something feels off about that for sure, if the math was good >>>>>>>>>> HHH should work cause the algo is so dead simple.

















    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 13:13:38 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 1:06 PM, dart200 wrote:
    On 10/31/26 10:55 AM, olcott wrote:
    On 10/31/2026 12:33 PM, dart200 wrote:
    On 10/31/26 9:31 AM, olcott wrote:
    On 10/31/2026 10:52 AM, dart200 wrote:
    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>>> simulates DD()

    DD simulated by HHH according to the operational semantics >>>>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>
    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>> simulated DD resulting in only a partial simulation

    a universal simulator (EYon as defined by turing himself) does >>>>>>>>>>>>> _not_ interfere with the simulation being run, like a >>>>>>>>>>>>> turing machine itself does not interfere with it's own >>>>>>>>>>>>> execution

    HHH does interfere, therefore it's not a universal
    simulator. it's only reporting on a truncated partial trace >>>>>>>>>>>>> of DD, not the full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>

    HHH is not EYon the universal simulator and does not simulate DD >>>>>>>>>>> in total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot >>>>>>>>> crap on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory): >>>>>>> line 01: simulated olcott() invokes all-caps macro repeating line 01 >>>>>>>
    looks like your own brain just entered the infinite recursion you >>>>>>> claimed HHH could detect. too bad HHH didn't abort before line 5. >>>>>>>

    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of
    professional experience


    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 }

    Then I do not see why that you cannot see that
    while DD is simulated by HHH you will not concede
    that this same DD simulated by HHH will not reach

    i've already conceded HHH(DD) does not simulate DD to line 06:
    HHH(DD) does a partial simulation of DD, and therefor will not
    simulate DD to line 06

    its own line 06, unless your primary goal is to
    be disagreeable.

    i'm agreeing with u polcott on that point, why are you being so
    disagreeable about it? Efn+

    If you fail to concede that DD simulated by HHH
    cannot reach its own line 06 while DD is being
    simulated by HHH

    or fail to show exactly how DD simulated by HHH
    does reach it own simulated line 06 while DD is
    being simulated by HHH I will end this conversation
    with you.

    let's suppose i could show that HHH(DD) simulating DD reaches line 06
    in the simulation ... how would that refute ur proof?


    With the credentials that you say that you have you
    would already know it is a logical impossibility.

    the only rebuttal u'll accept is in fact a logical impossibility?


    Until you say that you understand it is a logical
    impossibility you remain an Eliza bot in rebuttal mode.

    so u were just outright lying to me when u said such would be the only acceptable rebuttal... because it's _not_ an acceptable rebuttal





    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much bigger >>>>> reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the courtesy
    of reading all that i wrote, and that really is ur loss because i'm >>>>> most definitely not like the other chucklefucks around here




    HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>>> reach DD's return statement

    asking for a rebuttal to explain how HHH simulating DD
    reaches DDs return statement is just ... nonsense. HHH is >>>>>>>>>>> _not_ a universal simulator and does _not_ simulate DD in >>>>>>>>>>> total nor even is expected to do so!

    it is therefore _not_ actually reporting on a complete
    simulation of DD, objectively so as HHH cuts off DDs
    simulation before DD reaches it's final state. if u compared >>>>>>>>>>> the states the HHH(DD) records in it's simulation, this would >>>>>>>>>>> not match the states that EYon(DD) records in it's simulation. >>>>>>>>>>> HHH(DD) would match up to some point, at which point HHH(DD) >>>>>>>>>>> would record no more states, while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the >>>>>>>>>>> halting theorem in the slightest. i don't even think it's a >>>>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) >>>>>>>>>>> would return, if even. i bet it wouldn't, i bet
    HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>> reading by now tbh ... but you wanna know what i think is >>>>>>>>>>> useful about this issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an
    infinite looping recursion like what it tries on DD, because >>>>>>>>>>> that's how the inductive math proofs work. but u can't
    actually build a machine that totally implements that as an >>>>>>>>>>> automated prover precisely because of the machine DD that u >>>>>>>>>>> wrote...

    something feels off about that for sure, if the math was good >>>>>>>>>>> HHH should work cause the algo is so dead simple.



















    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 11:51:58 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/26 11:13 AM, olcott wrote:
    On 10/31/2026 1:06 PM, dart200 wrote:
    On 10/31/26 10:55 AM, olcott wrote:
    On 10/31/2026 12:33 PM, dart200 wrote:
    On 10/31/26 9:31 AM, olcott wrote:
    On 10/31/2026 10:52 AM, dart200 wrote:
    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>>>> simulates DD()

    DD simulated by HHH according to the operational semantics >>>>>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>>
    The only acceptable rebuttal
    show exactly how DD reaches its return statement >>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>>> simulated DD resulting in only a partial simulation >>>>>>>>>>>>>>
    a universal simulator (EYon as defined by turing himself) >>>>>>>>>>>>>> does _not_ interfere with the simulation being run, like a >>>>>>>>>>>>>> turing machine itself does not interfere with it's own >>>>>>>>>>>>>> execution

    HHH does interfere, therefore it's not a universal >>>>>>>>>>>>>> simulator. it's only reporting on a truncated partial >>>>>>>>>>>>>> trace of DD, not the full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>>

    HHH is not EYon the universal simulator and does not simulate >>>>>>>>>>>> DD in total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot >>>>>>>>>> crap on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory): >>>>>>>> line 01: simulated olcott() invokes all-caps macro repeating
    line 01

    looks like your own brain just entered the infinite recursion you >>>>>>>> claimed HHH could detect. too bad HHH didn't abort before line 5. >>>>>>>>

    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of
    professional experience


    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 }

    Then I do not see why that you cannot see that
    while DD is simulated by HHH you will not concede
    that this same DD simulated by HHH will not reach

    i've already conceded HHH(DD) does not simulate DD to line 06:
    HHH(DD) does a partial simulation of DD, and therefor will not
    simulate DD to line 06

    its own line 06, unless your primary goal is to
    be disagreeable.

    i'm agreeing with u polcott on that point, why are you being so
    disagreeable about it? Efn+

    If you fail to concede that DD simulated by HHH
    cannot reach its own line 06 while DD is being
    simulated by HHH

    or fail to show exactly how DD simulated by HHH
    does reach it own simulated line 06 while DD is
    being simulated by HHH I will end this conversation
    with you.

    let's suppose i could show that HHH(DD) simulating DD reaches line
    06 in the simulation ... how would that refute ur proof?


    With the credentials that you say that you have you
    would already know it is a logical impossibility.

    the only rebuttal u'll accept is in fact a logical impossibility?


    Until you say that you understand it is a logical
    impossibility you remain an Eliza bot in rebuttal mode.

    i already repeatedly agreed HHH(DD) does not simulate DD until line 6 polcott...

    the only question i'm left with:

    why are you lying about it being an acceptable rebuttal?


    so u were just outright lying to me when u said such would be the only
    acceptable rebuttal... because it's _not_ an acceptable rebuttal





    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much
    bigger reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the courtesy >>>>>> of reading all that i wrote, and that really is ur loss because
    i'm most definitely not like the other chucklefucks around here




    HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>>>> reach DD's return statement

    asking for a rebuttal to explain how HHH simulating DD >>>>>>>>>>>> reaches DDs return statement is just ... nonsense. HHH is >>>>>>>>>>>> _not_ a universal simulator and does _not_ simulate DD in >>>>>>>>>>>> total nor even is expected to do so!

    it is therefore _not_ actually reporting on a complete >>>>>>>>>>>> simulation of DD, objectively so as HHH cuts off DDs
    simulation before DD reaches it's final state. if u compared >>>>>>>>>>>> the states the HHH(DD) records in it's simulation, this >>>>>>>>>>>> would not match the states that EYon(DD) records in it's >>>>>>>>>>>> simulation. HHH(DD) would match up to some point, at which >>>>>>>>>>>> point HHH(DD) would record no more states, while EYon(DD) does. >>>>>>>>>>>>
    HHH is merely a broken algorithm that does not refute the >>>>>>>>>>>> halting theorem in the slightest. i don't even think it's a >>>>>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) >>>>>>>>>>>> would return, if even. i bet it wouldn't, i bet
    HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>>> reading by now tbh ... but you wanna know what i think is >>>>>>>>>>>> useful about this issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an >>>>>>>>>>>> infinite looping recursion like what it tries on DD, because >>>>>>>>>>>> that's how the inductive math proofs work. but u can't >>>>>>>>>>>> actually build a machine that totally implements that as an >>>>>>>>>>>> automated prover precisely because of the machine DD that u >>>>>>>>>>>> wrote...

    something feels off about that for sure, if the math was >>>>>>>>>>>> good HHH should work cause the algo is so dead simple. >>>>>>>>>>>>




















    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 13:58:25 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/2026 1:51 PM, dart200 wrote:
    On 10/31/26 11:13 AM, olcott wrote:
    On 10/31/2026 1:06 PM, dart200 wrote:
    On 10/31/26 10:55 AM, olcott wrote:
    On 10/31/2026 12:33 PM, dart200 wrote:
    On 10/31/26 9:31 AM, olcott wrote:
    On 10/31/2026 10:52 AM, dart200 wrote:
    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>>>>> simulates DD()

    DD simulated by HHH according to the operational semantics >>>>>>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>>>
    The only acceptable rebuttal
    show exactly how DD reaches its return statement >>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH


    HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>>>> simulated DD resulting in only a partial simulation >>>>>>>>>>>>>>>
    a universal simulator (EYon as defined by turing himself) >>>>>>>>>>>>>>> does _not_ interfere with the simulation being run, like >>>>>>>>>>>>>>> a turing machine itself does not interfere with it's own >>>>>>>>>>>>>>> execution

    HHH does interfere, therefore it's not a universal >>>>>>>>>>>>>>> simulator. it's only reporting on a truncated partial >>>>>>>>>>>>>>> trace of DD, not the full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement
    on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>>>

    HHH is not EYon the universal simulator and does not simulate >>>>>>>>>>>>> DD in total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot >>>>>>>>>>> crap on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory): >>>>>>>>> line 01: simulated olcott() invokes all-caps macro repeating >>>>>>>>> line 01

    looks like your own brain just entered the infinite recursion you >>>>>>>>> claimed HHH could detect. too bad HHH didn't abort before line 5. >>>>>>>>>

    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of
    professional experience


    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 }

    Then I do not see why that you cannot see that
    while DD is simulated by HHH you will not concede
    that this same DD simulated by HHH will not reach

    i've already conceded HHH(DD) does not simulate DD to line 06:
    HHH(DD) does a partial simulation of DD, and therefor will not
    simulate DD to line 06

    its own line 06, unless your primary goal is to
    be disagreeable.

    i'm agreeing with u polcott on that point, why are you being so
    disagreeable about it? Efn+

    If you fail to concede that DD simulated by HHH
    cannot reach its own line 06 while DD is being
    simulated by HHH

    or fail to show exactly how DD simulated by HHH
    does reach it own simulated line 06 while DD is
    being simulated by HHH I will end this conversation
    with you.

    let's suppose i could show that HHH(DD) simulating DD reaches line
    06 in the simulation ... how would that refute ur proof?


    With the credentials that you say that you have you
    would already know it is a logical impossibility.

    the only rebuttal u'll accept is in fact a logical impossibility?


    Until you say that you understand it is a logical
    impossibility you remain an Eliza bot in rebuttal mode.

    i already repeatedly agreed HHH(DD) does not simulate DD until line 6 polcott...


    That has the words backwards and you know it.
    This is your last chance.

    DD simulated by HHH does not reach its own
    simulated "return" statement on its own
    line 06 while DD simulated by HHH.

    the only question i'm left with:

    why are you lying about it being an acceptable rebuttal?


    so u were just outright lying to me when u said such would be the
    only acceptable rebuttal... because it's _not_ an acceptable rebuttal





    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much
    bigger reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the courtesy >>>>>>> of reading all that i wrote, and that really is ur loss because >>>>>>> i'm most definitely not like the other chucklefucks around here




    HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>>>>> reach DD's return statement

    asking for a rebuttal to explain how HHH simulating DD >>>>>>>>>>>>> reaches DDs return statement is just ... nonsense. HHH is >>>>>>>>>>>>> _not_ a universal simulator and does _not_ simulate DD in >>>>>>>>>>>>> total nor even is expected to do so!

    it is therefore _not_ actually reporting on a complete >>>>>>>>>>>>> simulation of DD, objectively so as HHH cuts off DDs >>>>>>>>>>>>> simulation before DD reaches it's final state. if u >>>>>>>>>>>>> compared the states the HHH(DD) records in it's simulation, >>>>>>>>>>>>> this would not match the states that EYon(DD) records in it's >>>>>>>>>>>>> simulation. HHH(DD) would match up to some point, at which >>>>>>>>>>>>> point HHH(DD) would record no more states, while EYon(DD) does. >>>>>>>>>>>>>
    HHH is merely a broken algorithm that does not refute the >>>>>>>>>>>>> halting theorem in the slightest. i don't even think it's a >>>>>>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) >>>>>>>>>>>>> would return, if even. i bet it wouldn't, i bet
    HHH(collatz_conj) diverges as written.

    now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>>>> reading by now tbh ... but you wanna know what i think is >>>>>>>>>>>>> useful about this issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an >>>>>>>>>>>>> infinite looping recursion like what it tries on DD, >>>>>>>>>>>>> because that's how the inductive math proofs work. but u >>>>>>>>>>>>> can't actually build a machine that totally implements that >>>>>>>>>>>>> as an automated prover precisely because of the machine DD >>>>>>>>>>>>> that u wrote...

    something feels off about that for sure, if the math was >>>>>>>>>>>>> good HHH should work cause the algo is so dead simple. >>>>>>>>>>>>>






















    --
    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,comp.lang.c,comp.lang.c++,comp.ai.philosophy on Sat Oct 31 12:13:21 2026
    From Newsgroup: comp.ai.philosophy

    On 10/31/26 11:58 AM, olcott wrote:
    On 10/31/2026 1:51 PM, dart200 wrote:
    On 10/31/26 11:13 AM, olcott wrote:
    On 10/31/2026 1:06 PM, dart200 wrote:
    On 10/31/26 10:55 AM, olcott wrote:
    On 10/31/2026 12:33 PM, dart200 wrote:
    On 10/31/26 9:31 AM, olcott wrote:
    On 10/31/2026 10:52 AM, dart200 wrote:
    On 10/31/26 8:42 AM, olcott wrote:
    On 10/31/2026 10:36 AM, dart200 wrote:
    On 10/31/26 8:25 AM, olcott wrote:
    On 10/31/2026 10:20 AM, dart200 wrote:
    On 10/31/26 4:58 AM, olcott wrote:
    On 10/31/2026 2:52 AM, dart200 wrote:
    On 10/30/26 9:26 PM, olcott wrote:
    On 10/30/2026 10:59 PM, dart200 wrote:
    On 10/30/26 8:54 PM, olcott wrote:
    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 }

    Mathematical proof of program correctness:
    Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>>>>>> simulates DD()

    DD simulated by HHH according to the operational semantics >>>>>>>>>>>>>>>>> of the C programming language cannot possibly reach its >>>>>>>>>>>>>>>>> own
    simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>>>>
    The only acceptable rebuttal
    show exactly how DD reaches its return statement >>>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH >>>>>>>>>>>>>>>>>

    HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>>>>> simulated DD resulting in only a partial simulation >>>>>>>>>>>>>>>>
    a universal simulator (EYon as defined by turing himself) >>>>>>>>>>>>>>>> does _not_ interfere with the simulation being run, like >>>>>>>>>>>>>>>> a turing machine itself does not interfere with it's own >>>>>>>>>>>>>>>> execution

    HHH does interfere, therefore it's not a universal >>>>>>>>>>>>>>>> simulator. it's only reporting on a truncated partial >>>>>>>>>>>>>>>> trace of DD, not the full execution of DD


    The only acceptable rebuttal
    show exactly how DD reaches its return statement >>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH
    EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>>>>

    HHH is not EYon the universal simulator and does not simulate >>>>>>>>>>>>>> DD in total.

    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT
    DISHONEST DODGE AWAY FROM THE POINT

    i'm trying to help u polcott and u pull this kinda brainrot >>>>>>>>>>>> crap on me


    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH
    DD WHILE IT IS BEING SIMULATED BY HHH

    simulation invariant (while olcott is simulated by comp.theory): >>>>>>>>>> line 01: simulated olcott() invokes all-caps macro repeating >>>>>>>>>> line 01

    looks like your own brain just entered the infinite recursion you >>>>>>>>>> claimed HHH could detect. too bad HHH didn't abort before line 5. >>>>>>>>>>

    So you never really were a programmer and
    want to hide your ignorance of programming
    by diversion and head games?

    Exactly what Are your programming credentials?

    i have a computer engineering degree from ucsd and ~10 yrs of >>>>>>>> professional experience


    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 }

    Then I do not see why that you cannot see that
    while DD is simulated by HHH you will not concede
    that this same DD simulated by HHH will not reach

    i've already conceded HHH(DD) does not simulate DD to line 06:
    HHH(DD) does a partial simulation of DD, and therefor will not
    simulate DD to line 06

    its own line 06, unless your primary goal is to
    be disagreeable.

    i'm agreeing with u polcott on that point, why are you being so
    disagreeable about it? Efn+

    If you fail to concede that DD simulated by HHH
    cannot reach its own line 06 while DD is being
    simulated by HHH

    or fail to show exactly how DD simulated by HHH
    does reach it own simulated line 06 while DD is
    being simulated by HHH I will end this conversation
    with you.

    let's suppose i could show that HHH(DD) simulating DD reaches line >>>>>> 06 in the simulation ... how would that refute ur proof?


    With the credentials that you say that you have you
    would already know it is a logical impossibility.

    the only rebuttal u'll accept is in fact a logical impossibility?


    Until you say that you understand it is a logical
    impossibility you remain an Eliza bot in rebuttal mode.

    i already repeatedly agreed HHH(DD) does not simulate DD until line 6
    polcott...


    That has the words backwards and you know it.

    HHH simulated with input DD, referred to by HHH(DD), simulates DD.

    this DD simulation by HHH(DD) does not reach line 06.

    what is backwards?

    This is your last chance.

    dud why do u keep making threats?


    DD simulated by HHH does not reach its own
    simulated "return" statement on its own
    line 06 while DD simulated by HHH.

    the only question i'm left with:

    why are you lying about it being an acceptable rebuttal?


    so u were just outright lying to me when u said such would be the
    only acceptable rebuttal... because it's _not_ an acceptable rebuttal





    The lack of a direct answer to this question
    will be taken as the reason to end this
    conversation with you.

    bruh u pulling fallacy after fallacy after fallacy is a much
    bigger reason for me to end the convo with you ...

    but haven't done that now, have i??? u don't give me the
    courtesy of reading all that i wrote, and that really is ur loss >>>>>>>> because i'm most definitely not like the other chucklefucks
    around here




    HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>>>>>> reach DD's return statement

    asking for a rebuttal to explain how HHH simulating DD >>>>>>>>>>>>>> reaches DDs return statement is just ... nonsense. HHH is >>>>>>>>>>>>>> _not_ a universal simulator and does _not_ simulate DD in >>>>>>>>>>>>>> total nor even is expected to do so!

    it is therefore _not_ actually reporting on a complete >>>>>>>>>>>>>> simulation of DD, objectively so as HHH cuts off DDs >>>>>>>>>>>>>> simulation before DD reaches it's final state. if u >>>>>>>>>>>>>> compared the states the HHH(DD) records in it's
    simulation, this would not match the states that EYon(DD) >>>>>>>>>>>>>> records in it's simulation. HHH(DD) would match up to some >>>>>>>>>>>>>> point, at which point HHH(DD) would record no more states, >>>>>>>>>>>>>> while EYon(DD) does.

    HHH is merely a broken algorithm that does not refute the >>>>>>>>>>>>>> halting theorem in the slightest. i don't even think it's >>>>>>>>>>>>>> a total algorithm cause who tf knows what
    HHH(collatz_conj) would return, if even. i bet it >>>>>>>>>>>>>> wouldn't, i bet HHH(collatz_conj) diverges as written. >>>>>>>>>>>>>>
    now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>>>>> reading by now tbh ... but you wanna know what i think is >>>>>>>>>>>>>> useful about this issue of HHH that you bring up?

    ur kinda right that HHH _should_ be able to detect an >>>>>>>>>>>>>> infinite looping recursion like what it tries on DD, >>>>>>>>>>>>>> because that's how the inductive math proofs work. but u >>>>>>>>>>>>>> can't actually build a machine that totally implements >>>>>>>>>>>>>> that as an automated prover precisely because of the >>>>>>>>>>>>>> machine DD that u wrote...

    something feels off about that for sure, if the math was >>>>>>>>>>>>>> good HHH should work cause the algo is so dead simple. >>>>>>>>>>>>>>
























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