• Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement

    From olcott@21:1/5 to Ben Bacarisse on Wed Mar 23 10:19:00 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/23/2022 10:08 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 10:36 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 9:39 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    Yet you cannot point out a single error in my halting problem
    refutation.
    The mistakes have been pointed out so many times that it's reasonable to >>>>> assume you can't see them or are simply ignoring them. The latest
    monster error is that if (as you claim) this is true of your Ĥ:
    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn"
    but
    "H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
    then Ĥ is not even a Truing machine, let alone the specific Ĥ in Linz's >>>>> proof.

    If the halt deciding criteria compares the finite strings of Turing
    machine descriptions...
    But Ĥ is not a Turing machine and ⟨Ĥ⟩ is not a Turing machine

    Technically Linz refers to a whole class of computations.

    No. Linz refer to Turing machine computations. Your PO-machines are
    not Turing machines because identical state transition functions entail different configuration sequences for identical inputs.

    description. You are not talking about Turing machines. Turing
    machines are not magic --

    identical state transition functions entail
    identical configuration sequences for the identical inputs.

    Yes that is correct.

    It is for Turing machines, but not your magic PO-machines. This:

    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn and H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn

    is magic, and can't happen if H and H^ are Turing machines. It's odd
    that you don't get this. I don't think you have every grasped what a
    Turing machine is.

    If you start with the foundational assumption that Linz is correct you
    can simply assume that my rebuttal is incorrect without even looking
    at it.

    I start wit the assumption that H is a Turing machine. You start
    with the assumption that H is not a Turing machine so sort of magic
    thing where an exact copy can entail a different sequence of
    transitions.

    Note that I am not rebutting anything -- your magic machine may well
    have the properties you claim. That's a another question, and one I
    don't care about.

    you are referring to entities with magic properties. For actual Turing
    machines, If Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn then H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qn.

    Not when Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis that Ĥ is invoking an
    identical machine description with identical inputs twice in sequence.

    If H and Ĥ magic (which is probably what you intend the vague words "on the bases that" to imply) I agree. You machines can do anything you like,
    but it says nothing about the proof you think is wrong.

    The finite string of ⟨H⟩ is not identical to the finite string of ⟨Ĥ⟩
    and the comparison of these finite strings is the halt deciding basis.

    If Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn then so does H ⟨Ĥ⟩ ⟨Ĥ⟩ unless H and Ĥ are
    not Turing machines.



    When we remove the infinite loop from Ĥ then
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    and
    H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn

    So in other words I am agreeing with a key element of what you are
    saying. I don't have the time to waste on elements that are not a direct
    part of my proof: H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Ben Bacarisse on Wed Mar 23 10:16:36 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/23/2022 10:08 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 10:36 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 9:39 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    Yet you cannot point out a single error in my halting problem
    refutation.
    The mistakes have been pointed out so many times that it's reasonable to >>>>> assume you can't see them or are simply ignoring them. The latest
    monster error is that if (as you claim) this is true of your Ĥ:
    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn"
    but
    "H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
    then Ĥ is not even a Truing machine, let alone the specific Ĥ in Linz's >>>>> proof.

    If the halt deciding criteria compares the finite strings of Turing
    machine descriptions...
    But Ĥ is not a Turing machine and ⟨Ĥ⟩ is not a Turing machine

    Technically Linz refers to a whole class of computations.

    No. Linz refer to Turing machine computations. Your PO-machines are
    not Turing machines because identical state transition functions entail different configuration sequences for identical inputs.

    description. You are not talking about Turing machines. Turing
    machines are not magic --

    identical state transition functions entail
    identical configuration sequences for the identical inputs.

    Yes that is correct.

    It is for Turing machines, but not your magic PO-machines. This:

    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn and H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn

    is magic, and can't happen if H and H^ are Turing machines. It's odd
    that you don't get this. I don't think you have every grasped what a
    Turing machine is.

    If you start with the foundational assumption that Linz is correct you
    can simply assume that my rebuttal is incorrect without even looking
    at it.

    I start wit the assumption that H is a Turing machine. You start
    with the assumption that H is not a Turing machine so sort of magic
    thing where an exact copy can entail a different sequence of
    transitions.

    Note that I am not rebutting anything -- your magic machine may well
    have the properties you claim. That's a another question, and one I
    don't care about.

    you are referring to entities with magic properties. For actual Turing
    machines, If Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn then H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qn.

    Not when Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis that Ĥ is invoking an
    identical machine description with identical inputs twice in sequence.

    If H and Ĥ magic (which is probably what you intend the vague words "on the bases that" to imply) I agree. You machines can do anything you like,
    but it says nothing about the proof you think is wrong.

    The finite string of ⟨H⟩ is not identical to the finite string of ⟨Ĥ⟩
    and the comparison of these finite strings is the halt deciding basis.

    If Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn then so does H ⟨Ĥ⟩ ⟨Ĥ⟩ unless H and Ĥ are
    not Turing machines.


    When we remove the infinite loop from Ĥ then
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    and
    Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn

    So in other words I am agreeing with a key element of what you are
    saying. I don't have the time to waste on elements that are not a direct
    part of my proof: H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Ben Bacarisse on Wed Mar 23 10:26:26 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
    olcott <NoOne@NoWhere.com> writes:

    A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
    If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
    final state.
    But for your "PO-machines":
    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
    corresponds to
    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
    and
    "The copy of H at Ĥ.qx correctly decides that its input never halts.
    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
    so this has nothing to do with Linz. He is talking about Turing >>>>>>> machines.


    The Linz conclusion only pertains to the behavior the copy of H
    embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

    Everything Linz says, everything, is predicated on what a Turing machine >>>>> is. Unlike Turing machines, your machines are magic -- identical state >>>>> transition functions can entail different configuration sequences for >>>>> the same input. Nothing you say has any relevance to Linz's Turing
    machines until you categorically repudiate this nonsense.

    That your only rebuttal to what I say now is dredging up what I said
    many months ago proves that you are being dishonest.
    You said this:
    "The copy of H at Ĥ.qx correctly decides that its input never halts. >>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts" >>
    If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
    same result. They are not identical final strings.

    If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any different transitions than H does, since they both have identical
    inputs. If one compares some strings, the other will too and they will
    both arrive as the same result and they will both behave in the same
    way. You H and Ĥ are obviously not Turing machines.

    I regret dropping down into simplistic metaphors. I'd rather keep this
    about formal Turing machines, but you don't really know what they are,
    and you certainly can't reason about them, so that hits a brick wall
    pretty quickly.

    four days ago and you haven't retracted it. Until you do, when you
    write Ĥ your readers must assume that you are referring to something
    about which this quote applies.
    What's more, for your remarks to have any bearing on Linz's Ĥ you must
    not only repudiate what you said, you must accept the converse,
    i.e. that if
    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
    then
    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
    So, do you retract what you said and accept this fact about Linz's H and >>> Ĥ?

    You you continue to say that you believe that a decider must report on
    its own behavior when you already know damn well that a decider only
    computes the mapping from its inputs to its own final state.

    I continue to believe that I know what a Turing machine is and that you don't. A Turing machine and an exact copy of it can't entail different sequences of transitions. Your H and Ĥ don't have this property. They
    are not Turing machines.


    I agree that a TM and an exact copy of it must entail the same sequence
    of transitions when applied to identical input.

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Ben Bacarisse on Wed Mar 23 17:27:13 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
    olcott <NoOne@NoWhere.com> writes:

    A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
    final state.
    But for your "PO-machines":
    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
    corresponds to
    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
    and
    "The copy of H at Ĥ.qx correctly decides that its input never halts.
    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
    so this has nothing to do with Linz. He is talking about Turing >>>>>>>>> machines.


    The Linz conclusion only pertains to the behavior the copy of H >>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

    Everything Linz says, everything, is predicated on what a Turing machine
    is. Unlike Turing machines, your machines are magic -- identical state >>>>>>> transition functions can entail different configuration sequences for >>>>>>> the same input. Nothing you say has any relevance to Linz's Turing >>>>>>> machines until you categorically repudiate this nonsense.

    That your only rebuttal to what I say now is dredging up what I said >>>>>> many months ago proves that you are being dishonest.
    You said this:
    "The copy of H at Ĥ.qx correctly decides that its input never halts.
    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

    If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
    same result. They are not identical final strings.
    If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
    different transitions than H does, since they both have identical
    inputs. If one compares some strings, the other will too and they will
    both arrive as the same result and they will both behave in the same
    way. You H and Ĥ are obviously not Turing machines.
    I regret dropping down into simplistic metaphors. I'd rather keep this
    about formal Turing machines, but you don't really know what they are,
    and you certainly can't reason about them, so that hits a brick wall
    pretty quickly.

    four days ago and you haven't retracted it. Until you do, when you
    write Ĥ your readers must assume that you are referring to something >>>>> about which this quote applies.
    What's more, for your remarks to have any bearing on Linz's Ĥ you must >>>>> not only repudiate what you said, you must accept the converse,
    i.e. that if
    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
    then
    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
    So, do you retract what you said and accept this fact about Linz's H and >>>>> Ĥ?

    You you continue to say that you believe that a decider must report on >>>> its own behavior when you already know damn well that a decider only
    computes the mapping from its inputs to its own final state.

    I continue to believe that I know what a Turing machine is and that you
    don't. A Turing machine and an exact copy of it can't entail different
    sequences of transitions. Your H and Ĥ don't have this property. They >>> are not Turing machines.

    I agree that a TM and an exact copy of it must entail the same
    sequence of transitions when applied to identical input.

    OK, but what about your magic PO-machines? They don't behave like this (apparently). It's easy to agree to facts about Turing machines, if
    your plan is to keep talking about machines where

    "The copy of H at Ĥ.qx correctly decides that its input never halts.
    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

    Not if H and Ĥ are identical and are not allowed to use their machine
    address to tell them apart.

    In my prior claims either H and Ĥ were not identical finite stings or
    they were identical finite stings at different machine addresses and
    they were allowed to use this machine address difference as their halt
    status criteria.

    From what I recall I explained all this before in complete detail but
    you were so sure that I must be wrong that your made sure to repeatedly
    always ignore this explanation.


    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Ben Bacarisse on Wed Mar 23 21:16:36 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/23/2022 8:47 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
    olcott <NoOne@NoWhere.com> writes:

    A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
    final state.
    But for your "PO-machines":
    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
    corresponds to
    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
    and
    "The copy of H at Ĥ.qx correctly decides that its input never halts.
    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
    so this has nothing to do with Linz. He is talking about Turing >>>>>>>>>>> machines.


    The Linz conclusion only pertains to the behavior the copy of H >>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

    Everything Linz says, everything, is predicated on what a Turing machine
    is. Unlike Turing machines, your machines are magic -- identical state
    transition functions can entail different configuration sequences for >>>>>>>>> the same input. Nothing you say has any relevance to Linz's Turing >>>>>>>>> machines until you categorically repudiate this nonsense.

    That your only rebuttal to what I say now is dredging up what I said >>>>>>>> many months ago proves that you are being dishonest.
    You said this:
    "The copy of H at Ĥ.qx correctly decides that its input never halts.
    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

    If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
    same result. They are not identical final strings.
    If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any >>>>> different transitions than H does, since they both have identical
    inputs. If one compares some strings, the other will too and they will >>>>> both arrive as the same result and they will both behave in the same >>>>> way. You H and Ĥ are obviously not Turing machines.
    I regret dropping down into simplistic metaphors. I'd rather keep this >>>>> about formal Turing machines, but you don't really know what they are, >>>>> and you certainly can't reason about them, so that hits a brick wall >>>>> pretty quickly.

    four days ago and you haven't retracted it. Until you do, when you >>>>>>> write Ĥ your readers must assume that you are referring to something >>>>>>> about which this quote applies.
    What's more, for your remarks to have any bearing on Linz's Ĥ you must >>>>>>> not only repudiate what you said, you must accept the converse,
    i.e. that if
    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
    then
    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
    So, do you retract what you said and accept this fact about Linz's H and
    Ĥ?

    You you continue to say that you believe that a decider must report on >>>>>> its own behavior when you already know damn well that a decider only >>>>>> computes the mapping from its inputs to its own final state.

    I continue to believe that I know what a Turing machine is and that you >>>>> don't. A Turing machine and an exact copy of it can't entail different >>>>> sequences of transitions. Your H and Ĥ don't have this property. They >>>>> are not Turing machines.

    I agree that a TM and an exact copy of it must entail the same
    sequence of transitions when applied to identical input.
    OK, but what about your magic PO-machines? They don't behave like this
    (apparently). It's easy to agree to facts about Turing machines, if
    your plan is to keep talking about machines where
    "The copy of H at Ĥ.qx correctly decides that its input never halts. >>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts" >>
    Not if H and Ĥ are identical and are not allowed to use their machine
    address to tell them apart.

    H and Ĥ are never identical. You know what the hat means don't you? So your magic PO-machines have machine addresses, do they? If so, that's another difference with Turing machines. You won't be able to say
    anything about Linz's proof unless you start to talk about Turing
    machines.

    In my prior claims either H and Ĥ were not identical finite stings

    You've lost the plot mate. Nether is even a string. If you made a
    prior claim about H or Ĥ being strings (whether identical or not), that
    was wrong too.

    As far as I can tell, when you write H and Ĥ we must assume that these
    refer to some kind of as yet unspecified machine that has "machine
    addresses" (so definitely not what Linz is taking about). And that
    these H and Ĥ have the property that H applied to some string can
    transition to a different state to an exact copy of H if it's embedded
    in some other machine. I suppose they don't actually have to be
    literally magic to do this, but they are certainly not Turing machines.

    Do you have anything to say about Linz's proof?


    All halt deciders must map their input to an accept or reject state
    based on the actual behavior actually specified by this input as
    measured by a finite number of N steps of the correct UTM simulation of
    this input.

    This does not mean that they must simulate their input. It means that
    the behavior that they are reporting on must be the same behavior that
    would occur by a UTM simulation of N steps.

    The constraint of a finite number of N steps is required to guarantee
    that the halt decider always reports.


    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Ben Bacarisse on Wed Mar 23 22:02:59 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/23/2022 9:31 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 8:47 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
    olcott <NoOne@NoWhere.com> writes:

    A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
    final state.
    But for your "PO-machines":
    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
    corresponds to
    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
    and
    "The copy of H at Ĥ.qx correctly decides that its input never halts.
    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
    so this has nothing to do with Linz. He is talking about Turing >>>>>>>>>>>>> machines.


    The Linz conclusion only pertains to the behavior the copy of H >>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

    Everything Linz says, everything, is predicated on what a Turing machine
    is. Unlike Turing machines, your machines are magic -- identical state
    transition functions can entail different configuration sequences for
    the same input. Nothing you say has any relevance to Linz's Turing >>>>>>>>>>> machines until you categorically repudiate this nonsense. >>>>>>>>>>
    That your only rebuttal to what I say now is dredging up what I said >>>>>>>>>> many months ago proves that you are being dishonest.
    You said this:
    "The copy of H at Ĥ.qx correctly decides that its input never halts.
    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

    If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
    same result. They are not identical final strings.
    If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any >>>>>>> different transitions than H does, since they both have identical >>>>>>> inputs. If one compares some strings, the other will too and they will >>>>>>> both arrive as the same result and they will both behave in the same >>>>>>> way. You H and Ĥ are obviously not Turing machines.
    I regret dropping down into simplistic metaphors. I'd rather keep this >>>>>>> about formal Turing machines, but you don't really know what they are, >>>>>>> and you certainly can't reason about them, so that hits a brick wall >>>>>>> pretty quickly.

    four days ago and you haven't retracted it. Until you do, when you >>>>>>>>> write Ĥ your readers must assume that you are referring to something >>>>>>>>> about which this quote applies.
    What's more, for your remarks to have any bearing on Linz's Ĥ you must
    not only repudiate what you said, you must accept the converse, >>>>>>>>> i.e. that if
    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
    then
    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
    So, do you retract what you said and accept this fact about Linz's H and
    Ĥ?

    You you continue to say that you believe that a decider must report on >>>>>>>> its own behavior when you already know damn well that a decider only >>>>>>>> computes the mapping from its inputs to its own final state.

    I continue to believe that I know what a Turing machine is and that you >>>>>>> don't. A Turing machine and an exact copy of it can't entail different >>>>>>> sequences of transitions. Your H and Ĥ don't have this property. They
    are not Turing machines.

    I agree that a TM and an exact copy of it must entail the same
    sequence of transitions when applied to identical input.
    OK, but what about your magic PO-machines? They don't behave like this >>>>> (apparently). It's easy to agree to facts about Turing machines, if >>>>> your plan is to keep talking about machines where
    "The copy of H at Ĥ.qx correctly decides that its input never halts.
    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

    Not if H and Ĥ are identical and are not allowed to use their machine >>>> address to tell them apart.
    H and Ĥ are never identical. You know what the hat means don't you? So >>> your magic PO-machines have machine addresses, do they? If so, that's
    another difference with Turing machines. You won't be able to say
    anything about Linz's proof unless you start to talk about Turing
    machines.

    In my prior claims either H and Ĥ were not identical finite stings
    You've lost the plot mate. Nether is even a string. If you made a
    prior claim about H or Ĥ being strings (whether identical or not), that >>> was wrong too.

    As far as I can tell, when you write H and Ĥ we must assume that these
    refer to some kind of as yet unspecified machine that has "machine
    addresses" (so definitely not what Linz is taking about). And that
    these H and Ĥ have the property that H applied to some string can
    transition to a different state to an exact copy of H if it's embedded
    in some other machine. I suppose they don't actually have to be
    literally magic to do this, but they are certainly not Turing machines.
    Do you have anything to say about Linz's proof?

    All halt deciders must map their input to an accept or reject state
    based on the actual behavior actually specified by this input as
    measured by a finite number of N steps of the correct UTM simulation
    of this input.

    No. You'll find what a halt decider must do in any good text book.

    It appears that after 17 years of work in this you are:

    (a) trying to redefine what that halting problem is;


    Someone that understands these things deeper than learned by rote would
    agree with me.

    (a) You agreed that every decider computes the mapping from its inputs
    to its own accept or reject state

    (b) You agreed that a halt decider must form its halt status decision on
    the actual behavior that is actually specified by its input.

    (c) You disagreed that a correct measure of the actual behavior that is actually specified by its input is a correct UTM simulation of N steps
    of this input.

    This would seem to indicate that you do not believe the direct execution
    of a Turing machine is computationally equivalent to the UTM simulation
    of the the machine description of this same machine.

    We must have the constraint of a finite N number of steps of simulation
    to require that the halt decider itself halts.

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Ben Bacarisse on Thu Mar 24 09:50:12 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/23/2022 11:21 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 9:31 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 8:47 PM, Ben Bacarisse wrote:

    As far as I can tell, when you write H and Ĥ we must assume that these >>>>> refer to some kind of as yet unspecified machine that has "machine
    addresses" (so definitely not what Linz is taking about). And that
    these H and Ĥ have the property that H applied to some string can
    transition to a different state to an exact copy of H if it's embedded >>>>> in some other machine. I suppose they don't actually have to be
    literally magic to do this, but they are certainly not Turing machines. >>>>> Do you have anything to say about Linz's proof?

    All halt deciders must map their input to an accept or reject state
    based on the actual behavior actually specified by this input as
    measured by a finite number of N steps of the correct UTM simulation
    of this input.

    No. You'll find what a halt decider must do in any good text book.
    It appears that after 17 years of work in this you are:

    (a) trying to redefine what that halting problem is;

    Someone that understands these things deeper than learned by rote
    would agree with me.

    No one agrees with the above. It's not the halting problem. What it
    is, ironically, is an admission that halting is undecidable! If you
    really thought it weren't, there would be no need to keep writing the condition for accepting an input incorrectly.


    Certainly you can state this dogmatically, yet what you cannot do is
    anchor this rebuttal in any sort of correct reasoning.

    In computability theory, the halting problem is the problem of
    determining, from a description of an arbitrary computer program and an
    input, whether the program will finish running, or continue to run
    forever. https://en.wikipedia.org/wiki/Halting_problem

    A halt decider must map its finite string input pair to an accept or
    reject state on the basis of the actual halting / non-halting behavior specified by this finite string pair.

    It is the case that all deciders compute the mapping from their input
    finite strings to their own accept or reject state.

    It is the case that all deciders compute the mapping from their input
    finite strings to their own accept or reject state on the basis of the
    behavior specified by these finite strings.

    It is the case that the behavior specified by these finite input strings
    is correctly measured by the correct UTM simulation of these strings by
    the simulating halt decider.

    It is the case that the correctly simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H
    would never reach its final state.

    It is the case that this causes the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H to fail to match the Linz definition of a computation that
    halts.

    computation that halts … the Turing machine will halt whenever it enters
    a final state. (Linz:1990:234)

    All of your replies have been dogma that would convince gullible fools.
    None of your replies have pointed out any error in the above.

    Bringing up things that I said months ago (your most recent tactic)
    unrelated to the above is a dishonest dodge and you know it.

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Mar 24 10:15:45 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/24/2022 9:58 AM, Richard Damon wrote:

    On 3/24/22 10:50 AM, olcott wrote:
    On 3/23/2022 11:21 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 9:31 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 8:47 PM, Ben Bacarisse wrote:

    As far as I can tell, when you write H and Ĥ we must assume that >>>>>>> these
    refer to some kind of as yet unspecified machine that has "machine >>>>>>> addresses" (so definitely not what Linz is taking about).  And that >>>>>>> these H and Ĥ have the property that H applied to some string can >>>>>>> transition to a different state to an exact copy of H if it's
    embedded
    in some other machine.  I suppose they don't actually have to be >>>>>>> literally magic to do this, but they are certainly not Turing
    machines.
    Do you have anything to say about Linz's proof?

    All halt deciders must map their input to an accept or reject state >>>>>> based on the actual behavior actually specified by this input as
    measured by a finite number of N steps of the correct UTM simulation >>>>>> of this input.

    No.  You'll find what a halt decider must do in any good text book. >>>>> It appears that after 17 years of work in this you are:

    (a) trying to redefine what that halting problem is;

    Someone that understands these things deeper than learned by rote
    would agree with me.

    No one agrees with the above.  It's not the halting problem.  What it
    is, ironically, is an admission that halting is undecidable!  If you
    really thought it weren't, there would be no need to keep writing the
    condition for accepting an input incorrectly.


    Certainly you can state this dogmatically, yet what you cannot do is
    anchor this rebuttal in any sort of correct reasoning.

    In computability theory, the halting problem is the problem of
    determining, from a description of an arbitrary computer program and
    an input, whether the program will finish running, or continue to run
    forever. https://en.wikipedia.org/wiki/Halting_problem

    A halt decider must map its finite string input pair to an accept or
    reject state on the basis of the actual halting / non-halting behavior
    specified by this finite string pair.

    It is the case that all deciders compute the mapping from their input
    finite strings to their own accept or reject state.

    It is the case that all deciders compute the mapping from their input
    finite strings to their own accept or reject state on the basis of the
    behavior specified by these finite strings.

    It is the case that the behavior specified by these finite input
    strings is correctly measured by the correct UTM simulation of these
    strings by the simulating halt decider.

    The CORRECT UTM Simulation (not N steps)

    This stupidly forbids simulating halt deciders from correctly rejecting
    their input. As soon as an infinite behavior pattern is correctly
    matched no more steps of simulation need be performed.

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to wij on Thu Mar 24 11:09:11 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/24/2022 10:58 AM, wij wrote:
    On Thursday, 24 March 2022 at 23:35:56 UTC+8, richar...@gmail.com wrote:
    ...[cut]
    I would challenge you to try to design a Turing Machine (not just an
    'equivalent, but an ACTUAL Turing Machine) that even trys to detect that
    its input is a representation of itself. (note, *A*, not *the* as
    machines have MANY (infinite) representations of themselves).

    That's the point. Not only PO don't have a complete H, he don't have a 'correct'
    P either. At most we can see his 'invalid' C implement:
    1. H does not exist. P can't exist.
    2. The H(P,P) in P should be a 'description' to be a formal proof.

    IMO, what PO need is basic logic, otherwise all is meaningless to him.

    When you simply assume that H does not exist then it logically follows
    that P does not exist. When you look at the actual x86 execution trace
    (on pages 4-5) you see that H does correctly determine that its input
    never halts and does correctly report this.

    https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu Mar 24 11:00:02 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/24/2022 10:35 AM, Richard Damon wrote:
    On 3/24/22 11:15 AM, olcott wrote:
    On 3/24/2022 9:58 AM, Richard Damon wrote:

    On 3/24/22 10:50 AM, olcott wrote:
    On 3/23/2022 11:21 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 9:31 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 8:47 PM, Ben Bacarisse wrote:

    As far as I can tell, when you write H and Ĥ we must assume >>>>>>>>> that these
    refer to some kind of as yet unspecified machine that has "machine >>>>>>>>> addresses" (so definitely not what Linz is taking about).  And >>>>>>>>> that
    these H and Ĥ have the property that H applied to some string can >>>>>>>>> transition to a different state to an exact copy of H if it's >>>>>>>>> embedded
    in some other machine.  I suppose they don't actually have to be >>>>>>>>> literally magic to do this, but they are certainly not Turing >>>>>>>>> machines.
    Do you have anything to say about Linz's proof?

    All halt deciders must map their input to an accept or reject state >>>>>>>> based on the actual behavior actually specified by this input as >>>>>>>> measured by a finite number of N steps of the correct UTM
    simulation
    of this input.

    No.  You'll find what a halt decider must do in any good text book. >>>>>>> It appears that after 17 years of work in this you are:

    (a) trying to redefine what that halting problem is;

    Someone that understands these things deeper than learned by rote
    would agree with me.

    No one agrees with the above.  It's not the halting problem.  What it >>>>> is, ironically, is an admission that halting is undecidable!  If you >>>>> really thought it weren't, there would be no need to keep writing the >>>>> condition for accepting an input incorrectly.


    Certainly you can state this dogmatically, yet what you cannot do is
    anchor this rebuttal in any sort of correct reasoning.

    In computability theory, the halting problem is the problem of
    determining, from a description of an arbitrary computer program and
    an input, whether the program will finish running, or continue to
    run forever. https://en.wikipedia.org/wiki/Halting_problem

    A halt decider must map its finite string input pair to an accept or
    reject state on the basis of the actual halting / non-halting
    behavior specified by this finite string pair.

    It is the case that all deciders compute the mapping from their
    input finite strings to their own accept or reject state.

    It is the case that all deciders compute the mapping from their
    input finite strings to their own accept or reject state on the
    basis of the behavior specified by these finite strings.

    It is the case that the behavior specified by these finite input
    strings is correctly measured by the correct UTM simulation of these
    strings by the simulating halt decider.

    The CORRECT UTM Simulation (not N steps)

    This stupidly forbids simulating halt deciders from correctly
    rejecting their input. As soon as an infinite behavior pattern is
    correctly matched no more steps of simulation need be performed.


    You need to CORRECTLY detect infininte behavior, EVEN IF the simulator
    aborts is simulation. For many machines, this isn't a problem (it only
    does become one if the machine contains a copy of the decider). That is
    your failing. Your 'proof' is based on false premises, that the decider
    will never abort.

    In fact, the bigger issue is that a real Turing Machine H can't actually detect that H^ is using a copy of itself, so it can't detect the
    recursion you are detecting. Your claims otherwise just show you don't understand how Turing Machines work.

    I would challenge you to try to design a Turing Machine (not just an 'equivalent, but an ACTUAL Turing Machine) that even trys to detect that
    its input is a representation of itself. (note, *A*, not *the* as
    machines have MANY (infinite) representations of themselves).

    Linz says that when embedded_H transitions to Ĥ.qn this necessarily
    forms a contradiction. https://www.liarparadox.org/Linz_Proof.pdf

    As long as embedded_H transitions to its final reject state aborting its
    input along with the whole chain of nested simulations then it is
    correct and refutes Linz even if embedded_H does this on the basis of a
    wild guess.


    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to wij on Thu Mar 24 12:00:48 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/24/2022 11:53 AM, wij wrote:
    On Friday, 25 March 2022 at 00:09:19 UTC+8, olcott wrote:
    On 3/24/2022 10:58 AM, wij wrote:
    On Thursday, 24 March 2022 at 23:35:56 UTC+8, richar...@gmail.com wrote: >>>> ...[cut]
    I would challenge you to try to design a Turing Machine (not just an
    'equivalent, but an ACTUAL Turing Machine) that even trys to detect that >>>> its input is a representation of itself. (note, *A*, not *the* as
    machines have MANY (infinite) representations of themselves).

    That's the point. Not only PO don't have a complete H, he don't have a 'correct'
    P either. At most we can see his 'invalid' C implement:
    1. H does not exist. P can't exist.
    2. The H(P,P) in P should be a 'description' to be a formal proof.

    IMO, what PO need is basic logic, otherwise all is meaningless to him.
    When you simply assume that H does not exist then it logically follows
    that P does not exist. When you look at the actual x86 execution trace
    (on pages 4-5) you see that H does correctly determine that its input
    never halts and does correctly report this.

    https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    Try replace the call 'H(x,x)' (or TM's codes) in your P with 'description', this
    is required by a formal proof.

    void P(u32 x)
    {
    if (H(x, x))
    HERE: goto HERE;
    }

    The x86 machine code of P is a 100% complete machine description of x.
    It is self-evident that the x86 emulation of the input to H cannot
    possibly ever reach its final state of [00000c50].

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to wij on Thu Mar 24 12:30:16 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/24/2022 12:21 PM, wij wrote:
    On Friday, 25 March 2022 at 01:00:56 UTC+8, olcott wrote:
    On 3/24/2022 11:53 AM, wij wrote:
    On Friday, 25 March 2022 at 00:09:19 UTC+8, olcott wrote:
    On 3/24/2022 10:58 AM, wij wrote:
    On Thursday, 24 March 2022 at 23:35:56 UTC+8, richar...@gmail.com wrote: >>>>>> ...[cut]
    I would challenge you to try to design a Turing Machine (not just an >>>>>> 'equivalent, but an ACTUAL Turing Machine) that even trys to detect that >>>>>> its input is a representation of itself. (note, *A*, not *the* as
    machines have MANY (infinite) representations of themselves).

    That's the point. Not only PO don't have a complete H, he don't have a 'correct'
    P either. At most we can see his 'invalid' C implement:
    1. H does not exist. P can't exist.
    2. The H(P,P) in P should be a 'description' to be a formal proof.

    IMO, what PO need is basic logic, otherwise all is meaningless to him. >>>> When you simply assume that H does not exist then it logically follows >>>> that P does not exist. When you look at the actual x86 execution trace >>>> (on pages 4-5) you see that H does correctly determine that its input
    never halts and does correctly report this.

    https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    Try replace the call 'H(x,x)' (or TM's codes) in your P with 'description', this
    is required by a formal proof.

    void P(u32 x)
    {
    if (H(x, x))
    HERE: goto HERE;
    }
    The x86 machine code of P is a 100% complete machine description of x.

    I mean replace the call 'H(x,x)' with the description (x86 machine code) of H.

    That is many hundreds of pages, all that we need to know is that it
    implements an x86 emulator that emulates one x86 instruction at a time
    and as soon as it detects an in infinite pattern it aborts and returns 0.

    It is self-evident on pages 4-5 that H does do this correctly.


    It is self-evident that the x86 emulation of the input to H cannot
    possibly ever reach its final state of [00000c50].

    Yes, I believe a faithful implement cannot reach [00000c50].


    That proves that H(P,P) == 0 is correct.

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer


    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Ben Bacarisse on Thu Mar 24 13:00:17 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/24/2022 12:51 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 11:21 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 9:31 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/23/2022 8:47 PM, Ben Bacarisse wrote:

    As far as I can tell, when you write H and Ĥ we must assume that these >>>>>>> refer to some kind of as yet unspecified machine that has "machine >>>>>>> addresses" (so definitely not what Linz is taking about). And that >>>>>>> these H and Ĥ have the property that H applied to some string can >>>>>>> transition to a different state to an exact copy of H if it's embedded >>>>>>> in some other machine. I suppose they don't actually have to be >>>>>>> literally magic to do this, but they are certainly not Turing machines. >>>>>>> Do you have anything to say about Linz's proof?

    All halt deciders must map their input to an accept or reject state >>>>>> based on the actual behavior actually specified by this input as
    measured by a finite number of N steps of the correct UTM simulation >>>>>> of this input.

    No. You'll find what a halt decider must do in any good text book.
    It appears that after 17 years of work in this you are:

    (a) trying to redefine what that halting problem is;

    Someone that understands these things deeper than learned by rote
    would agree with me.

    No one agrees with the above. It's not the halting problem. What it
    is, ironically, is an admission that halting is undecidable! If you
    really thought it weren't, there would be no need to keep writing the
    condition for accepting an input incorrectly.

    Certainly you can state this dogmatically, yet what you cannot do is
    anchor this rebuttal in any sort of correct reasoning.

    You are impervious to reasoning so I resorted to quoting you. You
    explicitly accept reject as the correct "mapping" for a string
    representing a halting computation. I'm not sure if there is a
    reasoning that could help you here.

    In computability theory, the halting problem is the problem of
    determining, from a description of an arbitrary computer program and
    an input, whether the program will finish running, or continue to run
    forever. https://en.wikipedia.org/wiki/Halting_problem

    A halt decider must map its finite string input pair to an accept or
    reject state on the basis of the actual halting / non-halting behavior
    specified by this finite string pair.

    Exactly. Yet you pretend you can't see that declaring reject to be the correct mapping for a string representing a halting computation is
    wrong. Do you really think there is anything I could say that would
    help you understand?

    It is the case that all deciders compute the mapping from their input
    finite strings to their own accept or reject state.

    Silly wording, but it's not wrong.

    It is the case that all deciders compute the mapping from their input
    finite strings to their own accept or reject state on the basis of the
    behavior specified by these finite strings.

    No, but only because you missed out a work. (A decider that accepts
    those string the encode prime numbers does not care about the
    "behaviour" specified by those strings.)

    It is the case that the behavior specified by these finite input
    strings is correctly measured by the correct UTM simulation of these
    strings by the simulating halt decider.

    Indeed. A pointless thing to do but you are obsessed with simulation so
    you prefer to write it that way.

    It is the case that the correctly simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to
    embedded_H would never reach its final state.

    That's a trick question.

    Not at all. If embedded_H would simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ as if embedded_H was a UTM then this simulated input would never reach its
    final state.


    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Ben Bacarisse on Thu Mar 24 20:00:13 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/24/2022 7:24 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/24/2022 12:51 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    It is the case that the correctly simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to >>>> embedded_H would never reach its final state.

    That's a trick question.

    Not at all. If embedded_H would simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ as if >> embedded_H was a UTM then this simulated input would never reach its
    final state.

    The fact that you keep using ever more vague and hand waving ways to
    avoid stating the correct condition should alert everyone to what you
    are doing. The correct condition is not about what "would happen if"
    things were not as they actually are.

    You've been trying this on for months: your Halts function was correct
    to reject a halting computation because of what "would happen if" line
    15 were commented out (line 15 was the abort that stopped halts from
    being a UTM).


    I think that the problem is that you really want to disagree at all
    costs and that you understood that I am correct many months ago.
    No recent rebuttals by anyone have been coherent.

    Because the only fake rebuttal that you have is pointing out that I made
    a mistake (many months ago) on something not related to my current proof
    I take this as evidence that you can't find anything wrong with my
    current proof.

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

    It is the case that the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to simulating
    halt decider embedded_H cannot reach its final state. This conclusively
    proves that this simulated input fails to meet the Linz definition of
    halting.

    computation that halts … the Turing machine will halt whenever it enters
    a final state. (Linz:1990:234)

    This conclusively proves the if embedded_H rejects its input it is correct.

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Ben Bacarisse on Thu Mar 24 22:23:03 2022
    XPost: comp.theory, sci.logic, sci.math

    On 3/24/2022 9:19 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/24/2022 7:24 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 3/24/2022 12:51 PM, Ben Bacarisse wrote:
    olcott <NoOne@NoWhere.com> writes:

    It is the case that the correctly simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to >>>>>> embedded_H would never reach its final state.

    That's a trick question.

    Not at all. If embedded_H would simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ as if >>>> embedded_H was a UTM then this simulated input would never reach its
    final state.

    The fact that you keep using ever more vague and hand waving ways to
    avoid stating the correct condition should alert everyone to what you
    are doing. The correct condition is not about what "would happen if"
    things were not as they actually are.
    You've been trying this on for months: your Halts function was correct
    to reject a halting computation because of what "would happen if" line
    15 were commented out (line 15 was the abort that stopped halts from
    being a UTM).

    I think that the problem is that you really want to disagree at all
    costs and that you understood that I am correct many months ago. No
    recent rebuttals by anyone have been coherent.

    I'll leave that for others to decide, but /you/ are not competent to
    assess what I've said. Every time you try to paraphrase my words the
    result has been junk (though that might have been deliberate).

    This is what I am talking about now.
    I will not respond to anything else.

    This is what I am talking about now.
    I will not respond to anything else

    This is what I am talking about now.
    I will not respond to anything else

    This is what I am talking about now.
    I will not respond to anything else

    This is what I am talking about now.
    I will not respond to anything else

    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

    It is the case that the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to simulating
    halt decider embedded_H cannot reach its final state. This conclusively
    proves that this simulated input fails to meet the Linz definition of
    halting.

    computation that halts … the Turing machine will halt whenever it enters
    a final state. (Linz:1990:234)

    This conclusively proves the if embedded_H rejects its input it is correct.

    --
    Copyright 2021 Pete Olcott

    Talent hits a target no one else can hit;
    Genius hits a target no one else can see.
    Arthur Schopenhauer

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)