• Re: Halting Problem Proof ERROR

    From Fred. Zwarts@F.Zwarts@HetNet.nl to comp.theory,comp.ai.philosophy,sci.logic on Mon Jul 21 10:10:03 2025
    From Newsgroup: comp.ai.philosophy

    Op 20.jul.2025 om 17:16 schreef olcott:
    On 7/20/2025 2:54 AM, Fred. Zwarts wrote:
    Op 19.jul.2025 om 16:23 schreef olcott:
    On 7/19/2025 3:26 AM, Fred. Zwarts wrote:
    Op 18.jul.2025 om 18:09 schreef olcott:
    On 7/18/2025 6:17 AM, Fred. Zwarts wrote:
    Op 17.jul.2025 om 16:44 schreef olcott:
    On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
    [ Followup-To: set ]

    In comp.theory olcott <polcott333@gmail.com> wrote:
    On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
    olcott <polcott333@gmail.com> wrote:
    On 7/5/2025 2:07 PM, Alan Mackenzie wrote:

    You lie.  You don't have a proof.  Many people in this group >>>>>>>>>>>> have pointed
    out lots of errors in various versions of your purported >>>>>>>>>>>> proof, which you
    just ignore.  The section in Professor Linz's book you used >>>>>>>>>>>> to be so fond
    of citing will contain plenty of details, if only you would >>>>>>>>>>>> take the
    trouble to understand it (assuming you're capable of such >>>>>>>>>>>> understanding).

    I have addressed ....

    Meaningless pompous word.

    .... all of those details that you make sure to ignore so >>>>>>>>>>> that you can
    baselessly claim that I am wrong.

    I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>> understanding.  It was like watching a 7 year old trying to do >>>>>>>>>> calculus.
    The basic understanding was simply not there.  Years later, >>>>>>>>>> it's still
    not there.

    And yes, you are wrong.  The proofs of the halting theorem >>>>>>>>>> which involve
    constructing programs which purported halting deciders cannot >>>>>>>>>> decide
    correctly are correct.

    Yet you cannot point to even one mistake because there are none. >>>>>>>>
    That's what I'm saying.  Those proofs of the halting theorem are >>>>>>>> free
    from mistakes.

    More to the point, it is YOU who cannot point to any mistakes in >>>>>>>> them.
    They are valid proofs.  Your work, if it contradicts those
    proofs (which
    isn't at all clear) can thus be dismissed without further
    consideration.

    There cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>> opposite of whatever its decider decides. All of the examples >>>>>>>>>>> of this have never been *ACTUAL INPUTS*

    That's so sloppily worded, it could mean almost anything.

    The standard halting problem proof cannot even be constructed. >>>>>>>>
    It has been constructed, and is valid.  But one would normally >>>>>>>> talk about
    formulating a proof, rather than constructing one.

    [ .... ]

    No Turing machine can possibly take another directly executing >>>>>>>>>>> Turing machine as in input, thus removing these from the >>>>>>>>>>> domain of every halt decider.

    And that, too.

    *Thus the requirement that HHH report on the behavior*
    *of the directly executed DD has always been bogus*

    And that makes your hat trick.

    Turing machine partial halt deciders compute the mapping >>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>> inputs specify.

    And a fourth.  There's some semblance of truth in there, but >>>>>>>>>> it's very
    confused.


    It is not at all confused. I know exactly what it means.

    It's very confused to everybody but you, then.

    Sloppy wording is your technique to get people to go down to >>>>>>>>>> your level
    of discussion.  That involves many posts trying just to tie >>>>>>>>>> you down to
    specific word meanings, and is very tiresome and unrewarding. >>>>>>>>>> I decline
    to get involved any further.


    *Yet as I claimed you found no actual mistake*

    I've found plenty of actual mistakes.  I was a software
    developer by
    profession.

    Let me tell you the punchline so that you can
    see why I said those things.

    Despite what I said last post, I will actually go to the trouble of >>>>>>>> analysing your sloppy expression.

    Because directly executed Turing machines cannot
    possibly be inputs to Turing machine deciders this
    makes them outside of the domain of these deciders.

    It's entirely unclear what a "directly executed Turing machine" >>>>>>>> is. Most
    of the time turing machines are theoretical constructs used for >>>>>>>> proving
    theorems.  They can be executed, but rarely are.

    It's unclear what you mean by a turing machine being an input to >>>>>>>> a turing
    machine.  Read up about universal turing machines to get a bit of >>>>>>>> background.

    When a partial halt decider is required to report
    on the direct execution of a machine this requirement
    is bogus.

    See above.  That paragraph is meaningless.

    This means that the behavior of DD() is none of the damn
    business of HHH, thus does not contradict HHH(DD)==0.
    *If you disagree this only proves that you do not understand* >>>>>>>>
    It's fully obscure what DD() and HHH mean, and thus impossible to >>>>>>>> affirm or contradict the meaningless "HHH(DD)==0".

    HHH(DD) does correctly detect that DD simulated by HHH
    according to the semantics pf the C programming language
    cannot possibly reach its own "return"statement final
    halt state.

    See above.  By the way, people concerned with computation theory >>>>>>>> use
    turing machines, which are well-defined, simple, and powerful. >>>>>>>> They lack
    the complexity, ambiguity, and unsuitability for theoretical
    work of real
    world programming languages like C.

    *If you disagree this only proves that you do not understand* >>>>>>>>
    Any mindless idiot can disagree. Showing an error and proving >>>>>>>>> that it is an actual mistake requires much more than this.

    Indeed.  All you have done is disagree with one of the proofs of >>>>>>>> the
    halting theorem.  You have yet to show an error in it.  That >>>>>>>> will be
    difficult, because there aren't any.


    q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
        if M applied to WM halts, and
    q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
        if M applied to WM does not halt.

    *From the bottom of page 319 has been adapted to this*
    https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>>    if Ĥ applied to ⟨Ĥ⟩ halts, and
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
       if Ĥ applied to ⟨Ĥ⟩ does not halt.

    <*Halting Problem Proof ERROR*>

    Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
    direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
    ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.

    No Turing Machine decider can ever report on the
    behavior of anything that is not an input encoded
    as a finite string.

    Ĥ is not a finite string input to Ĥ.embedded_H
    ⟨Ĥ⟩ ⟨Ĥ⟩ are finite string inputs to Ĥ.embedded_H

    </*Halting Problem Proof ERROR*>

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
         its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>>>      reach its simulated final halt state of ⟨Ĥ.qn⟩.

    When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a
    simulating partial halt decider
    (a) Ĥ copies its input ⟨Ĥ⟩
    (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
    (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (g) goto (d) with one more level of simulation until
    *embedded_H sees the repeating pattern and transitions to Ĥ.qn*

    But when this is only finite repeating pattern,

    The infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
    cannot possibly reach its own simulated final
    halt state of ⟨Ĥ.qn⟩ you fucking moron.

    But that infinite simulation exists only in your dreams and is
    counter- factual. Ĥ aborts and the same abort code is present in
    embedded_H (unless you are cheating), so there is no infinite
    recursion, no infinite repeating pattern. The correct simulation
    will reach the final halt state.

    When you change my words and use those words as the basis
    of your rebuttal you know that you cheat.

    The infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
    cannot possibly reach its own simulated final
    halt state of ⟨Ĥ.qn⟩ you fucking moron.
    No rebuttal, only repeated claims without evidence. Ĥ and embedded_H
    have the same code, including the abort code. Your claim of an
    infinite simulation is a counter-factual dream.
    And ad hominem attacks are evidence for a lack of arguments.

    As usual, no rebuttal, but only a repetition of incorrect claims without
    any evidence:


    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
        ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
        its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
        ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
        reach its simulated final halt state of ⟨Ĥ.qn⟩.

    When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a
    simulating partial halt decider
    (a) Ĥ copies its input ⟨Ĥ⟩
    (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
    (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (g) goto (d) with one more level of simulation until
    embedded_H sees the repeating pattern and transitions to Ĥ.qn.

    This has already been proven to be incomplete.
    in (g), we need to replace 'repeating pattern' with 'finite repeating pattern', because not all repetitions are infinite and a finite
    repetition is not a measure for non-halting. So we can continue:

    (h) Ĥ has the same detection and abort code as embedded_H.
    (i) A correct simulation would reach the final halt state after a few repetitions.
    (j) When embedded_h fails to reach this final halt state, it guesses incorrectly that no such final halt state exists.
    (k) Embedded_ reports the invalid result that Ĥ does not halt, based on
    an aborted finite repetition and a wild guess.


    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,comp.ai.philosophy,sci.logic on Mon Jul 21 08:36:26 2025
    From Newsgroup: comp.ai.philosophy

    On 7/21/2025 3:10 AM, Fred. Zwarts wrote:
    Op 20.jul.2025 om 17:16 schreef olcott:
    On 7/20/2025 2:54 AM, Fred. Zwarts wrote:
    Op 19.jul.2025 om 16:23 schreef olcott:
    On 7/19/2025 3:26 AM, Fred. Zwarts wrote:
    Op 18.jul.2025 om 18:09 schreef olcott:
    On 7/18/2025 6:17 AM, Fred. Zwarts wrote:
    Op 17.jul.2025 om 16:44 schreef olcott:
    On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
    [ Followup-To: set ]

    In comp.theory olcott <polcott333@gmail.com> wrote:
    On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
    olcott <polcott333@gmail.com> wrote:
    On 7/5/2025 2:07 PM, Alan Mackenzie wrote:

    You lie.  You don't have a proof.  Many people in this >>>>>>>>>>>>> group have pointed
    out lots of errors in various versions of your purported >>>>>>>>>>>>> proof, which you
    just ignore.  The section in Professor Linz's book you used >>>>>>>>>>>>> to be so fond
    of citing will contain plenty of details, if only you would >>>>>>>>>>>>> take the
    trouble to understand it (assuming you're capable of such >>>>>>>>>>>>> understanding).

    I have addressed ....

    Meaningless pompous word.

    .... all of those details that you make sure to ignore so >>>>>>>>>>>> that you can
    baselessly claim that I am wrong.

    I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>>> understanding.  It was like watching a 7 year old trying to >>>>>>>>>>> do calculus.
    The basic understanding was simply not there.  Years later, >>>>>>>>>>> it's still
    not there.

    And yes, you are wrong.  The proofs of the halting theorem >>>>>>>>>>> which involve
    constructing programs which purported halting deciders cannot >>>>>>>>>>> decide
    correctly are correct.

    Yet you cannot point to even one mistake because there are none. >>>>>>>>>
    That's what I'm saying.  Those proofs of the halting theorem >>>>>>>>> are free
    from mistakes.

    More to the point, it is YOU who cannot point to any mistakes >>>>>>>>> in them.
    They are valid proofs.  Your work, if it contradicts those >>>>>>>>> proofs (which
    isn't at all clear) can thus be dismissed without further
    consideration.

    There cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>>> opposite of whatever its decider decides. All of the examples >>>>>>>>>>>> of this have never been *ACTUAL INPUTS*

    That's so sloppily worded, it could mean almost anything.

    The standard halting problem proof cannot even be constructed. >>>>>>>>>
    It has been constructed, and is valid.  But one would normally >>>>>>>>> talk about
    formulating a proof, rather than constructing one.

    [ .... ]

    No Turing machine can possibly take another directly executing >>>>>>>>>>>> Turing machine as in input, thus removing these from the >>>>>>>>>>>> domain of every halt decider.

    And that, too.

    *Thus the requirement that HHH report on the behavior* >>>>>>>>>>>> *of the directly executed DD has always been bogus*

    And that makes your hat trick.

    Turing machine partial halt deciders compute the mapping >>>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>>> inputs specify.

    And a fourth.  There's some semblance of truth in there, but >>>>>>>>>>> it's very
    confused.


    It is not at all confused. I know exactly what it means.

    It's very confused to everybody but you, then.

    Sloppy wording is your technique to get people to go down to >>>>>>>>>>> your level
    of discussion.  That involves many posts trying just to tie >>>>>>>>>>> you down to
    specific word meanings, and is very tiresome and unrewarding. >>>>>>>>>>> I decline
    to get involved any further.


    *Yet as I claimed you found no actual mistake*

    I've found plenty of actual mistakes.  I was a software
    developer by
    profession.

    Let me tell you the punchline so that you can
    see why I said those things.

    Despite what I said last post, I will actually go to the
    trouble of
    analysing your sloppy expression.

    Because directly executed Turing machines cannot
    possibly be inputs to Turing machine deciders this
    makes them outside of the domain of these deciders.

    It's entirely unclear what a "directly executed Turing machine" >>>>>>>>> is. Most
    of the time turing machines are theoretical constructs used for >>>>>>>>> proving
    theorems.  They can be executed, but rarely are.

    It's unclear what you mean by a turing machine being an input >>>>>>>>> to a turing
    machine.  Read up about universal turing machines to get a bit of >>>>>>>>> background.

    When a partial halt decider is required to report
    on the direct execution of a machine this requirement
    is bogus.

    See above.  That paragraph is meaningless.

    This means that the behavior of DD() is none of the damn
    business of HHH, thus does not contradict HHH(DD)==0.
    *If you disagree this only proves that you do not understand* >>>>>>>>>
    It's fully obscure what DD() and HHH mean, and thus impossible to >>>>>>>>> affirm or contradict the meaningless "HHH(DD)==0".

    HHH(DD) does correctly detect that DD simulated by HHH
    according to the semantics pf the C programming language
    cannot possibly reach its own "return"statement final
    halt state.

    See above.  By the way, people concerned with computation
    theory use
    turing machines, which are well-defined, simple, and powerful. >>>>>>>>> They lack
    the complexity, ambiguity, and unsuitability for theoretical >>>>>>>>> work of real
    world programming languages like C.

    *If you disagree this only proves that you do not understand* >>>>>>>>>
    Any mindless idiot can disagree. Showing an error and proving >>>>>>>>>> that it is an actual mistake requires much more than this.

    Indeed.  All you have done is disagree with one of the proofs >>>>>>>>> of the
    halting theorem.  You have yet to show an error in it.  That >>>>>>>>> will be
    difficult, because there aren't any.


    q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
        if M applied to WM halts, and
    q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
        if M applied to WM does not halt.

    *From the bottom of page 319 has been adapted to this*
    https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>>>    if Ĥ applied to ⟨Ĥ⟩ halts, and
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>    if Ĥ applied to ⟨Ĥ⟩ does not halt.

    <*Halting Problem Proof ERROR*>

    Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
    direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
    ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.

    No Turing Machine decider can ever report on the
    behavior of anything that is not an input encoded
    as a finite string.

    Ĥ is not a finite string input to Ĥ.embedded_H
    ⟨Ĥ⟩ ⟨Ĥ⟩ are finite string inputs to Ĥ.embedded_H

    </*Halting Problem Proof ERROR*>

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ >>>>>>>>      ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
         its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>      ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>>>>      reach its simulated final halt state of ⟨Ĥ.qn⟩.

    When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a
    simulating partial halt decider
    (a) Ĥ copies its input ⟨Ĥ⟩
    (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
    (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (g) goto (d) with one more level of simulation until
    *embedded_H sees the repeating pattern and transitions to Ĥ.qn* >>>>>>>
    But when this is only finite repeating pattern,

    The infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
    cannot possibly reach its own simulated final
    halt state of ⟨Ĥ.qn⟩ you fucking moron.

    But that infinite simulation exists only in your dreams and is
    counter- factual. Ĥ aborts and the same abort code is present in
    embedded_H (unless you are cheating), so there is no infinite
    recursion, no infinite repeating pattern. The correct simulation
    will reach the final halt state.

    When you change my words and use those words as the basis
    of your rebuttal you know that you cheat.

    The infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
    cannot possibly reach its own simulated final
    halt state of ⟨Ĥ.qn⟩ you fucking moron.
    No rebuttal, only repeated claims without evidence. Ĥ and embedded_H
    have the same code, including the abort code. Your claim of an
    infinite simulation is a counter-factual dream.
    And ad hominem attacks are evidence for a lack of arguments.

    As usual, no rebuttal, but only a repetition of incorrect claims without
    any evidence:


    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
         its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
         reach its simulated final halt state of ⟨Ĥ.qn⟩.

    When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a
    simulating partial halt decider
    (a) Ĥ copies its input ⟨Ĥ⟩
    (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
    (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (g) goto (d) with one more level of simulation until
    embedded_H sees the repeating pattern and transitions to Ĥ.qn.

    This has already been proven to be incomplete.
    in (g), we need to replace 'repeating pattern' with 'finite repeating pattern', because not all repetitions are infinite and a finite
    repetition is not a measure for non-halting. So we can continue:


    void Infinite_Loop()
    {
    HERE: goto HERE;
    return;
    }

    HHH(Infinite_Loop) is the same sort of finite repeating pattern.

    (h) Ĥ has the same detection and abort code as embedded_H.
    (i) A correct simulation would reach the final halt state after a few repetitions.
    (j) When embedded_h fails to reach this final halt state, it guesses incorrectly that no such final halt state exists.
    (k) Embedded_ reports the invalid result that Ĥ does not halt, based on
    an aborted finite repetition and a wild guess.


    --
    Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
    hits a target no one else can see." Arthur Schopenhauer
    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From olcott@polcott333@gmail.com to comp.theory,sci.logic,comp.ai.philosophy on Mon Jul 21 09:04:38 2025
    From Newsgroup: comp.ai.philosophy

    On 7/21/2025 4:28 AM, Mikko wrote:
    On 2025-07-20 15:02:30 +0000, olcott said:

    On 7/20/2025 3:39 AM, Mikko wrote:
    On 2025-07-19 15:11:21 +0000, olcott said:

    On 7/19/2025 3:05 AM, Mikko wrote:
    On 2025-07-17 14:44:23 +0000, olcott said:

    On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
    [ Followup-To: set ]

    In comp.theory olcott <polcott333@gmail.com> wrote:
    On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
    olcott <polcott333@gmail.com> wrote:
    On 7/5/2025 2:07 PM, Alan Mackenzie wrote:

    You lie.  You don't have a proof.  Many people in this group >>>>>>>>>>> have pointed
    out lots of errors in various versions of your purported >>>>>>>>>>> proof, which you
    just ignore.  The section in Professor Linz's book you used >>>>>>>>>>> to be so fond
    of citing will contain plenty of details, if only you would >>>>>>>>>>> take the
    trouble to understand it (assuming you're capable of such >>>>>>>>>>> understanding).

    I have addressed ....

    Meaningless pompous word.

    .... all of those details that you make sure to ignore so that >>>>>>>>>> you can
    baselessly claim that I am wrong.

    I vaguely remember rolling my eyes at your hopeless lack of
    understanding.  It was like watching a 7 year old trying to do >>>>>>>>> calculus.
    The basic understanding was simply not there.  Years later, >>>>>>>>> it's still
    not there.

    And yes, you are wrong.  The proofs of the halting theorem >>>>>>>>> which involve
    constructing programs which purported halting deciders cannot >>>>>>>>> decide
    correctly are correct.

    Yet you cannot point to even one mistake because there are none. >>>>>>>
    That's what I'm saying.  Those proofs of the halting theorem are >>>>>>> free
    from mistakes.

    More to the point, it is YOU who cannot point to any mistakes in >>>>>>> them.
    They are valid proofs.  Your work, if it contradicts those proofs >>>>>>> (which
    isn't at all clear) can thus be dismissed without further
    consideration.

    There cannot possibly be *AN ACTUAL INPUT* that does the
    opposite of whatever its decider decides. All of the examples >>>>>>>>>> of this have never been *ACTUAL INPUTS*

    That's so sloppily worded, it could mean almost anything.

    The standard halting problem proof cannot even be constructed.

    It has been constructed, and is valid.  But one would normally >>>>>>> talk about
    formulating a proof, rather than constructing one.

    [ .... ]

    No Turing machine can possibly take another directly executing >>>>>>>>>> Turing machine as in input, thus removing these from the
    domain of every halt decider.

    And that, too.

    *Thus the requirement that HHH report on the behavior*
    *of the directly executed DD has always been bogus*

    And that makes your hat trick.

    Turing machine partial halt deciders compute the mapping
    from their actual inputs to the actual behavior that these >>>>>>>>>> inputs specify.

    And a fourth.  There's some semblance of truth in there, but >>>>>>>>> it's very
    confused.


    It is not at all confused. I know exactly what it means.

    It's very confused to everybody but you, then.

    Sloppy wording is your technique to get people to go down to >>>>>>>>> your level
    of discussion.  That involves many posts trying just to tie you >>>>>>>>> down to
    specific word meanings, and is very tiresome and unrewarding. >>>>>>>>> I decline
    to get involved any further.


    *Yet as I claimed you found no actual mistake*

    I've found plenty of actual mistakes.  I was a software developer by >>>>>>> profession.

    Let me tell you the punchline so that you can
    see why I said those things.

    Despite what I said last post, I will actually go to the trouble of >>>>>>> analysing your sloppy expression.

    Because directly executed Turing machines cannot
    possibly be inputs to Turing machine deciders this
    makes them outside of the domain of these deciders.

    It's entirely unclear what a "directly executed Turing machine" >>>>>>> is.  Most
    of the time turing machines are theoretical constructs used for >>>>>>> proving
    theorems.  They can be executed, but rarely are.

    It's unclear what you mean by a turing machine being an input to >>>>>>> a turing
    machine.  Read up about universal turing machines to get a bit of >>>>>>> background.

    When a partial halt decider is required to report
    on the direct execution of a machine this requirement
    is bogus.

    See above.  That paragraph is meaningless.

    This means that the behavior of DD() is none of the damn
    business of HHH, thus does not contradict HHH(DD)==0.
    *If you disagree this only proves that you do not understand*

    It's fully obscure what DD() and HHH mean, and thus impossible to >>>>>>> affirm or contradict the meaningless "HHH(DD)==0".

    HHH(DD) does correctly detect that DD simulated by HHH
    according to the semantics pf the C programming language
    cannot possibly reach its own "return"statement final
    halt state.

    See above.  By the way, people concerned with computation theory use >>>>>>> turing machines, which are well-defined, simple, and powerful. >>>>>>> They lack
    the complexity, ambiguity, and unsuitability for theoretical work >>>>>>> of real
    world programming languages like C.

    *If you disagree this only proves that you do not understand*

    Any mindless idiot can disagree. Showing an error and proving
    that it is an actual mistake requires much more than this.

    Indeed.  All you have done is disagree with one of the proofs of the >>>>>>> halting theorem.  You have yet to show an error in it.  That will be >>>>>>> difficult, because there aren't any.

    q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
        if M applied to WM halts, and
    q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
        if M applied to WM does not halt.

    This means nothing as long as symbols are undefined.

    They are defined on the link provided on the next line.

    That was not said in the quoted message, and some of the symbols
    are not defined there.

    *From the bottom of page 319 has been adapted to this*
    https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
       if Ĥ applied to ⟨Ĥ⟩ halts, and
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
       if Ĥ applied to ⟨Ĥ⟩ does not halt.

    <*Halting Problem Proof ERROR*>

    Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
    direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
    ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.

    It is not clear what is the subject of the sentence. It makes a big
    difference who or what requires. Some requirements are essential to
    the topic but others may be irrelevant or even bogus.


    <ChatGPT>
    Misrepresentation of Input:
    The standard proof assumes a decider
    H(M,x) that determines whether machine
    M halts on input x.

    But this formulation is flawed, because:
    Turing machines can only process finite
    encodings (e.g. ⟨M⟩), not executable entities
    like M.

    So the valid formulation must be
    H(⟨M⟩,x), where ⟨M⟩ is a string.
    </ChatGPT>

    This notation refers to Turing Machine: Ĥ
    This notation refers to TM description: ⟨Ĥ⟩

    The complete context is provided in the original proof
    https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

    *Here is the corrected proof*
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
         its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
         reach its simulated final halt state of ⟨Ĥ.qn⟩.

    Ĥ.embedded_H correctly transitions to Ĥ.qn.

    The question about the missing subject remains unanswered. Apparently
    you don't know what you were talking about.

    The key subject to me is this:
    How does Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to Ĥ.qn correctly?

    (a) Ĥ copies its input ⟨Ĥ⟩
    (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
    (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (g) goto (d) with one more level of simulation until
    embedded_H sees the repeating pattern and transitions to Ĥ.qn.

    None of which is relevant to the point what is not a garamamtical
    sentence cannot be true.


    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
    if Ĥ applied to ⟨Ĥ⟩ halts, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    if Ĥ applied to ⟨Ĥ⟩ does not halt.

    *The above incorrect proof is corrected below*

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
    ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
    its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
    reach its simulated final halt state of ⟨Ĥ.qn⟩.
    --
    Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
    hits a target no one else can see." Arthur Schopenhauer
    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From Fred. Zwarts@F.Zwarts@HetNet.nl to comp.theory,comp.ai.philosophy,sci.logic on Tue Jul 22 11:20:02 2025
    From Newsgroup: comp.ai.philosophy

    Op 21.jul.2025 om 15:36 schreef olcott:
    On 7/21/2025 3:10 AM, Fred. Zwarts wrote:
    Op 20.jul.2025 om 17:16 schreef olcott:
    On 7/20/2025 2:54 AM, Fred. Zwarts wrote:
    Op 19.jul.2025 om 16:23 schreef olcott:
    On 7/19/2025 3:26 AM, Fred. Zwarts wrote:
    Op 18.jul.2025 om 18:09 schreef olcott:
    On 7/18/2025 6:17 AM, Fred. Zwarts wrote:
    Op 17.jul.2025 om 16:44 schreef olcott:
    On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
    [ Followup-To: set ]

    In comp.theory olcott <polcott333@gmail.com> wrote:
    On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
    olcott <polcott333@gmail.com> wrote:
    On 7/5/2025 2:07 PM, Alan Mackenzie wrote:

    You lie.  You don't have a proof.  Many people in this >>>>>>>>>>>>>> group have pointed
    out lots of errors in various versions of your purported >>>>>>>>>>>>>> proof, which you
    just ignore.  The section in Professor Linz's book you >>>>>>>>>>>>>> used to be so fond
    of citing will contain plenty of details, if only you >>>>>>>>>>>>>> would take the
    trouble to understand it (assuming you're capable of such >>>>>>>>>>>>>> understanding).

    I have addressed ....

    Meaningless pompous word.

    .... all of those details that you make sure to ignore so >>>>>>>>>>>>> that you can
    baselessly claim that I am wrong.

    I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>>>> understanding.  It was like watching a 7 year old trying to >>>>>>>>>>>> do calculus.
    The basic understanding was simply not there.  Years later, >>>>>>>>>>>> it's still
    not there.

    And yes, you are wrong.  The proofs of the halting theorem >>>>>>>>>>>> which involve
    constructing programs which purported halting deciders >>>>>>>>>>>> cannot decide
    correctly are correct.

    Yet you cannot point to even one mistake because there are none. >>>>>>>>>>
    That's what I'm saying.  Those proofs of the halting theorem >>>>>>>>>> are free
    from mistakes.

    More to the point, it is YOU who cannot point to any mistakes >>>>>>>>>> in them.
    They are valid proofs.  Your work, if it contradicts those >>>>>>>>>> proofs (which
    isn't at all clear) can thus be dismissed without further >>>>>>>>>> consideration.

    There cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>>>> opposite of whatever its decider decides. All of the examples >>>>>>>>>>>>> of this have never been *ACTUAL INPUTS*

    That's so sloppily worded, it could mean almost anything. >>>>>>>>>>
    The standard halting problem proof cannot even be constructed. >>>>>>>>>>
    It has been constructed, and is valid.  But one would normally >>>>>>>>>> talk about
    formulating a proof, rather than constructing one.

    [ .... ]

    No Turing machine can possibly take another directly executing >>>>>>>>>>>>> Turing machine as in input, thus removing these from the >>>>>>>>>>>>> domain of every halt decider.

    And that, too.

    *Thus the requirement that HHH report on the behavior* >>>>>>>>>>>>> *of the directly executed DD has always been bogus*

    And that makes your hat trick.

    Turing machine partial halt deciders compute the mapping >>>>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>>>> inputs specify.

    And a fourth.  There's some semblance of truth in there, but >>>>>>>>>>>> it's very
    confused.


    It is not at all confused. I know exactly what it means.

    It's very confused to everybody but you, then.

    Sloppy wording is your technique to get people to go down to >>>>>>>>>>>> your level
    of discussion.  That involves many posts trying just to tie >>>>>>>>>>>> you down to
    specific word meanings, and is very tiresome and
    unrewarding. I decline
    to get involved any further.


    *Yet as I claimed you found no actual mistake*

    I've found plenty of actual mistakes.  I was a software
    developer by
    profession.

    Let me tell you the punchline so that you can
    see why I said those things.

    Despite what I said last post, I will actually go to the
    trouble of
    analysing your sloppy expression.

    Because directly executed Turing machines cannot
    possibly be inputs to Turing machine deciders this
    makes them outside of the domain of these deciders.

    It's entirely unclear what a "directly executed Turing
    machine" is. Most
    of the time turing machines are theoretical constructs used >>>>>>>>>> for proving
    theorems.  They can be executed, but rarely are.

    It's unclear what you mean by a turing machine being an input >>>>>>>>>> to a turing
    machine.  Read up about universal turing machines to get a bit of >>>>>>>>>> background.

    When a partial halt decider is required to report
    on the direct execution of a machine this requirement
    is bogus.

    See above.  That paragraph is meaningless.

    This means that the behavior of DD() is none of the damn >>>>>>>>>>> business of HHH, thus does not contradict HHH(DD)==0.
    *If you disagree this only proves that you do not understand* >>>>>>>>>>
    It's fully obscure what DD() and HHH mean, and thus impossible to >>>>>>>>>> affirm or contradict the meaningless "HHH(DD)==0".

    HHH(DD) does correctly detect that DD simulated by HHH
    according to the semantics pf the C programming language >>>>>>>>>>> cannot possibly reach its own "return"statement final
    halt state.

    See above.  By the way, people concerned with computation >>>>>>>>>> theory use
    turing machines, which are well-defined, simple, and powerful. >>>>>>>>>> They lack
    the complexity, ambiguity, and unsuitability for theoretical >>>>>>>>>> work of real
    world programming languages like C.

    *If you disagree this only proves that you do not understand* >>>>>>>>>>
    Any mindless idiot can disagree. Showing an error and proving >>>>>>>>>>> that it is an actual mistake requires much more than this. >>>>>>>>>>
    Indeed.  All you have done is disagree with one of the proofs >>>>>>>>>> of the
    halting theorem.  You have yet to show an error in it.  That >>>>>>>>>> will be
    difficult, because there aren't any.


    q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
        if M applied to WM halts, and
    q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
        if M applied to WM does not halt.

    *From the bottom of page 319 has been adapted to this*
    https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>>>>    if Ĥ applied to ⟨Ĥ⟩ halts, and
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>    if Ĥ applied to ⟨Ĥ⟩ does not halt.

    <*Halting Problem Proof ERROR*>

    Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
    direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
    ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.

    No Turing Machine decider can ever report on the
    behavior of anything that is not an input encoded
    as a finite string.

    Ĥ is not a finite string input to Ĥ.embedded_H
    ⟨Ĥ⟩ ⟨Ĥ⟩ are finite string inputs to Ĥ.embedded_H

    </*Halting Problem Proof ERROR*>

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞ >>>>>>>>>      ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches >>>>>>>>>      its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>      ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>>>>>      reach its simulated final halt state of ⟨Ĥ.qn⟩. >>>>>>>>>
    When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a
    simulating partial halt decider
    (a) Ĥ copies its input ⟨Ĥ⟩
    (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
    (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (g) goto (d) with one more level of simulation until
    *embedded_H sees the repeating pattern and transitions to Ĥ.qn* >>>>>>>>
    But when this is only finite repeating pattern,

    The infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
    cannot possibly reach its own simulated final
    halt state of ⟨Ĥ.qn⟩ you fucking moron.

    But that infinite simulation exists only in your dreams and is
    counter- factual. Ĥ aborts and the same abort code is present in >>>>>> embedded_H (unless you are cheating), so there is no infinite
    recursion, no infinite repeating pattern. The correct simulation
    will reach the final halt state.

    When you change my words and use those words as the basis
    of your rebuttal you know that you cheat.

    The infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
    cannot possibly reach its own simulated final
    halt state of ⟨Ĥ.qn⟩ you fucking moron.
    No rebuttal, only repeated claims without evidence. Ĥ and embedded_H >>>> have the same code, including the abort code. Your claim of an
    infinite simulation is a counter-factual dream.
    And ad hominem attacks are evidence for a lack of arguments.

    As usual, no rebuttal, but only a repetition of incorrect claims
    without any evidence:


    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
         its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
         reach its simulated final halt state of ⟨Ĥ.qn⟩.

    When Ĥ is applied to ⟨Ĥ⟩ and embedded_H is a
    simulating partial halt decider
    (a) Ĥ copies its input ⟨Ĥ⟩
    (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
    (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (g) goto (d) with one more level of simulation until
    embedded_H sees the repeating pattern and transitions to Ĥ.qn.

    This has already been proven to be incomplete.
    in (g), we need to replace 'repeating pattern' with 'finite repeating
    pattern', because not all repetitions are infinite and a finite
    repetition is not a measure for non-halting. So we can continue:


    void Infinite_Loop()
    {
      HERE: goto HERE;
      return;
    }

    HHH(Infinite_Loop) is the same sort of finite repeating pattern.

    No, Finite_Recursion looks like the recursion specified in the input for
    HHH:

    void Finite_Recursion (int N) {
    if (N > 0) Finite_Recursion (N - 1);
    printf ("Olcott thinks this is never printed.\n");
    }

    You fails to see the difference between infinite recursion and finite recursion. Probably because you are still dreaming of an HHH that does
    not abort, even when the HHH is specified in the input to abort and
    return. That your HHH fails to reach that point is no measure for the behaviour specified in the input.
    --- Synchronet 3.21a-Linux NewsLink 1.2
  • From Fred. Zwarts@F.Zwarts@HetNet.nl to comp.theory,sci.logic,comp.ai.philosophy on Tue Jul 22 11:23:21 2025
    From Newsgroup: comp.ai.philosophy

    Op 21.jul.2025 om 16:04 schreef olcott:
    On 7/21/2025 4:28 AM, Mikko wrote:
    On 2025-07-20 15:02:30 +0000, olcott said:

    On 7/20/2025 3:39 AM, Mikko wrote:
    On 2025-07-19 15:11:21 +0000, olcott said:

    On 7/19/2025 3:05 AM, Mikko wrote:
    On 2025-07-17 14:44:23 +0000, olcott said:

    On 7/6/2025 11:02 AM, Alan Mackenzie wrote:
    [ Followup-To: set ]

    In comp.theory olcott <polcott333@gmail.com> wrote:
    On 7/6/2025 5:16 AM, Alan Mackenzie wrote:
    olcott <polcott333@gmail.com> wrote:
    On 7/5/2025 2:07 PM, Alan Mackenzie wrote:

    You lie.  You don't have a proof.  Many people in this group >>>>>>>>>>>> have pointed
    out lots of errors in various versions of your purported >>>>>>>>>>>> proof, which you
    just ignore.  The section in Professor Linz's book you used >>>>>>>>>>>> to be so fond
    of citing will contain plenty of details, if only you would >>>>>>>>>>>> take the
    trouble to understand it (assuming you're capable of such >>>>>>>>>>>> understanding).

    I have addressed ....

    Meaningless pompous word.

    .... all of those details that you make sure to ignore so >>>>>>>>>>> that you can
    baselessly claim that I am wrong.

    I vaguely remember rolling my eyes at your hopeless lack of >>>>>>>>>> understanding.  It was like watching a 7 year old trying to do >>>>>>>>>> calculus.
    The basic understanding was simply not there.  Years later, >>>>>>>>>> it's still
    not there.

    And yes, you are wrong.  The proofs of the halting theorem >>>>>>>>>> which involve
    constructing programs which purported halting deciders cannot >>>>>>>>>> decide
    correctly are correct.

    Yet you cannot point to even one mistake because there are none. >>>>>>>>
    That's what I'm saying.  Those proofs of the halting theorem are >>>>>>>> free
    from mistakes.

    More to the point, it is YOU who cannot point to any mistakes in >>>>>>>> them.
    They are valid proofs.  Your work, if it contradicts those
    proofs (which
    isn't at all clear) can thus be dismissed without further
    consideration.

    There cannot possibly be *AN ACTUAL INPUT* that does the >>>>>>>>>>> opposite of whatever its decider decides. All of the examples >>>>>>>>>>> of this have never been *ACTUAL INPUTS*

    That's so sloppily worded, it could mean almost anything.

    The standard halting problem proof cannot even be constructed. >>>>>>>>
    It has been constructed, and is valid.  But one would normally >>>>>>>> talk about
    formulating a proof, rather than constructing one.

    [ .... ]

    No Turing machine can possibly take another directly executing >>>>>>>>>>> Turing machine as in input, thus removing these from the >>>>>>>>>>> domain of every halt decider.

    And that, too.

    *Thus the requirement that HHH report on the behavior*
    *of the directly executed DD has always been bogus*

    And that makes your hat trick.

    Turing machine partial halt deciders compute the mapping >>>>>>>>>>> from their actual inputs to the actual behavior that these >>>>>>>>>>> inputs specify.

    And a fourth.  There's some semblance of truth in there, but >>>>>>>>>> it's very
    confused.


    It is not at all confused. I know exactly what it means.

    It's very confused to everybody but you, then.

    Sloppy wording is your technique to get people to go down to >>>>>>>>>> your level
    of discussion.  That involves many posts trying just to tie >>>>>>>>>> you down to
    specific word meanings, and is very tiresome and unrewarding. >>>>>>>>>> I decline
    to get involved any further.


    *Yet as I claimed you found no actual mistake*

    I've found plenty of actual mistakes.  I was a software
    developer by
    profession.

    Let me tell you the punchline so that you can
    see why I said those things.

    Despite what I said last post, I will actually go to the trouble of >>>>>>>> analysing your sloppy expression.

    Because directly executed Turing machines cannot
    possibly be inputs to Turing machine deciders this
    makes them outside of the domain of these deciders.

    It's entirely unclear what a "directly executed Turing machine" >>>>>>>> is.  Most
    of the time turing machines are theoretical constructs used for >>>>>>>> proving
    theorems.  They can be executed, but rarely are.

    It's unclear what you mean by a turing machine being an input to >>>>>>>> a turing
    machine.  Read up about universal turing machines to get a bit of >>>>>>>> background.

    When a partial halt decider is required to report
    on the direct execution of a machine this requirement
    is bogus.

    See above.  That paragraph is meaningless.

    This means that the behavior of DD() is none of the damn
    business of HHH, thus does not contradict HHH(DD)==0.
    *If you disagree this only proves that you do not understand* >>>>>>>>
    It's fully obscure what DD() and HHH mean, and thus impossible to >>>>>>>> affirm or contradict the meaningless "HHH(DD)==0".

    HHH(DD) does correctly detect that DD simulated by HHH
    according to the semantics pf the C programming language
    cannot possibly reach its own "return"statement final
    halt state.

    See above.  By the way, people concerned with computation theory >>>>>>>> use
    turing machines, which are well-defined, simple, and powerful. >>>>>>>> They lack
    the complexity, ambiguity, and unsuitability for theoretical
    work of real
    world programming languages like C.

    *If you disagree this only proves that you do not understand* >>>>>>>>
    Any mindless idiot can disagree. Showing an error and proving >>>>>>>>> that it is an actual mistake requires much more than this.

    Indeed.  All you have done is disagree with one of the proofs of >>>>>>>> the
    halting theorem.  You have yet to show an error in it.  That >>>>>>>> will be
    difficult, because there aren't any.

    q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ∞,
        if M applied to WM halts, and
    q0 WM ⊢* Ĥq0 Wm WM ⊢* Ĥ y1 qn y2,
        if M applied to WM does not halt.

    This means nothing as long as symbols are undefined.

    They are defined on the link provided on the next line.

    That was not said in the quoted message, and some of the symbols
    are not defined there.

    *From the bottom of page 319 has been adapted to this*
    https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, >>>>>>>    if Ĥ applied to ⟨Ĥ⟩ halts, and
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
       if Ĥ applied to ⟨Ĥ⟩ does not halt.

    <*Halting Problem Proof ERROR*>

    Requires Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on the
    direct execution of Ĥ applied to ⟨Ĥ⟩ and thus not
    ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.

    It is not clear what is the subject of the sentence. It makes a big >>>>>> difference who or what requires. Some requirements are essential to >>>>>> the topic but others may be irrelevant or even bogus.


    <ChatGPT>
    Misrepresentation of Input:
    The standard proof assumes a decider
    H(M,x) that determines whether machine
    M halts on input x.

    But this formulation is flawed, because:
    Turing machines can only process finite
    encodings (e.g. ⟨M⟩), not executable entities
    like M.

    So the valid formulation must be
    H(⟨M⟩,x), where ⟨M⟩ is a string.
    </ChatGPT>

    This notation refers to Turing Machine: Ĥ
    This notation refers to TM description: ⟨Ĥ⟩

    The complete context is provided in the original proof
    https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

    *Here is the corrected proof*
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
         its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
         ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>      reach its simulated final halt state of ⟨Ĥ.qn⟩.

    Ĥ.embedded_H correctly transitions to Ĥ.qn.

    The question about the missing subject remains unanswered. Apparently
    you don't know what you were talking about.

    The key subject to me is this:
    How does Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to Ĥ.qn correctly?

    (a) Ĥ copies its input ⟨Ĥ⟩
    (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
    (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (g) goto (d) with one more level of simulation until
    embedded_H sees the repeating pattern and transitions to Ĥ.qn.

    None of which is relevant to the point what is not a garamamtical
    sentence cannot be true.


    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
       if Ĥ applied to ⟨Ĥ⟩ halts, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
       if Ĥ applied to ⟨Ĥ⟩ does not halt.

    *The above incorrect proof is corrected below*

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
       ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
       its simulated final halt state of ⟨Ĥ.qn⟩, and

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
       ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
       reach its simulated final halt state of ⟨Ĥ.qn⟩.
    It is unable to prove either halting or non-halting, showing that it is
    not the right tool for this input. Other deciders are able to get the
    correct result for exctly the same input.
    --- Synchronet 3.21a-Linux NewsLink 1.2