• Re: Correcting logic to make it a system of correct reasoning [ previou

    From olcott@21:1/5 to Ben on Sat May 14 09:00:20 2022
    XPost: comp.theory, sci.logic

    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong because
    it contradicts the definition of a computer science decider in some
    rare cases that no one never noticed before.

    Well that's pretty clear. The halting problem, as defined by everyone
    by you (i.e. about which computations are finite and which are not) is
    indeed undecidable.


    Not at all. We must simply correct the error of the halting problem
    definition so that it does not diverge from the definition of a decider
    thus causes it to diverge from the definition of a computation.

    You are even (almost) correct about the halting theorem. The two
    notions of "computation" and "halt decider", as conventionally defined,
    are contradictory.


    *The corrected halting problem definition*
    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 *specified by this description* will finish
    running, or continue to run forever. https://en.wikipedia.org/wiki/Halting_problem


    --
    Copyright 2022 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 Richard Damon@21:1/5 to olcott on Sat May 14 10:31:40 2022
    XPost: comp.theory, sci.logic

    On 5/14/22 10:00 AM, olcott wrote:
    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong because
    it contradicts the definition of a computer science decider in some
    rare cases that no one never noticed before.

    Well that's pretty clear.  The halting problem, as defined by everyone
    by you (i.e. about which computations are finite and which are not) is
    indeed undecidable.


    Not at all. We must simply correct the error of the halting problem definition so that it does not diverge from the definition of a decider
    thus causes it to diverge from the definition of a computation.

    You are even (almost) correct about the halting theorem.  The two
    notions of "computation" and "halt decider", as conventionally defined,
    are contradictory.


    *The corrected halting problem definition*
    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 *specified by this description* will finish running,  or continue to run forever. https://en.wikipedia.org/wiki/Halting_problem



    WRONG, you don't get to change the definition of the Problem.

    You are just proving that you don't understand the nature of logic, or
    of Truth.

    The Halting Problem STARTS with some arbitrary program. If that program
    can't be specified to the "decider", then the decider just fails to be
    an answer to the Halting Problem.

    Otherwise, I can trivially write a "correct" halt decider by just
    defining that it can accept a very limited set of encoded programs (like
    none with backward jumps), and then I can easily decide if they will
    halt or not.

    This example shows the incorrectness of YOUR (false) definition.

    You just continue to prove your ignorance of the field.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Sat May 14 09:53:53 2022
    XPost: comp.theory, sci.logic

    On 5/14/2022 9:31 AM, Richard Damon wrote:
    On 5/14/22 10:00 AM, olcott wrote:
    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong because >>>> it contradicts the definition of a computer science decider in some
    rare cases that no one never noticed before.

    Well that's pretty clear.  The halting problem, as defined by everyone
    by you (i.e. about which computations are finite and which are not) is
    indeed undecidable.


    Not at all. We must simply correct the error of the halting problem
    definition so that it does not diverge from the definition of a
    decider thus causes it to diverge from the definition of a computation.

    You are even (almost) correct about the halting theorem.  The two
    notions of "computation" and "halt decider", as conventionally defined,
    are contradictory.


    *The corrected halting problem definition*
    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 *specified by this description* will
    finish running,  or continue to run forever.
    https://en.wikipedia.org/wiki/Halting_problem



    WRONG, you don't get to change the definition of the Problem.


    [ computer science is inconsistent ]
    If two definitions within computer science contradict each other then
    computer science itself is an inconsistent system thus conclusively
    proving that computer science diverges from correct reasoning.

    If all halt deciders must compute the mapping from their inputs to an accept/reject state on the basis of the actual behavior that this input actually specifies and the halting problem specifies that a halt decider
    must compute the mapping from non-inputs, then one of these two must go
    or computer science remains inconsistent.

    learned-by-rote people that only know things by-the-book tend to take
    the gospel of textbooks as holy words contradictions and all.

    Like with religious people they tend to believe that the contradictions
    are somehow resolved at a level higher than their current understanding.

    You are just proving that you don't understand the nature of logic, or
    of Truth.

    The Halting Problem STARTS with some arbitrary program. If that program
    can't be specified to the "decider", then the decider just fails to be
    an answer to the Halting Problem.

    Otherwise, I can trivially write a "correct" halt decider by just
    defining that it can accept a very limited set of encoded programs (like
    none with backward jumps), and then I can easily decide if they will
    halt or not.

    This example shows the incorrectness of YOUR (false) definition.

    You just continue to prove your ignorance of the field.


    --
    Copyright 2022 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 Richard Damon@21:1/5 to olcott on Sat May 14 11:33:12 2022
    XPost: comp.theory, sci.logic

    On 5/14/22 10:53 AM, olcott wrote:
    On 5/14/2022 9:31 AM, Richard Damon wrote:
    On 5/14/22 10:00 AM, olcott wrote:
    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong because >>>>> it contradicts the definition of a computer science decider in some
    rare cases that no one never noticed before.

    Well that's pretty clear.  The halting problem, as defined by everyone >>>> by you (i.e. about which computations are finite and which are not) is >>>> indeed undecidable.


    Not at all. We must simply correct the error of the halting problem
    definition so that it does not diverge from the definition of a
    decider thus causes it to diverge from the definition of a computation.

    You are even (almost) correct about the halting theorem.  The two
    notions of "computation" and "halt decider", as conventionally defined, >>>> are contradictory.


    *The corrected halting problem definition*
    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 *specified by this description* will
    finish running,  or continue to run forever.
    https://en.wikipedia.org/wiki/Halting_problem



    WRONG, you don't get to change the definition of the Problem.


    [ computer science is inconsistent ]
    If two definitions within computer science contradict each other then computer science itself is an inconsistent system thus conclusively
    proving that computer science diverges from correct reasoning.

    If all halt deciders must compute the mapping from their inputs to an accept/reject state on the basis of the actual behavior that this input actually specifies and the halting problem specifies that a halt decider
    must compute the mapping from non-inputs, then one of these two must go
    or computer science remains inconsistent.

    learned-by-rote people that only know things by-the-book tend to take
    the gospel of textbooks as holy words contradictions and all.

    Like with religious people they tend to believe that the contradictions
    are somehow resolved at a level higher than their current understanding.

    Except that you are ignoring that the definitions are NOT inconsistent,
    unless you require that Halting be computable.

    The Halting Mapping of Turing Machines is well defined, as a mapping of
    a Turing Machine + finite String Input -> { Halting, Non-Halting} based
    on if the Turing Machine will reach a final state in any finite number
    of steps, or never reach such a final state after an unbounded number of
    step.

    Right? That is a very straight forward definition, and all Inputs have a
    well defined and definite output. No Machine + Input can do both be
    Halting and Non-Halting, or fail to be at least one of Halting or
    Non-Halting. (Either then number of steps processed halts at a finite
    number in a final state or counts to an unbounded number).

    A Decider, always maps an input (in its domain) to an output (in its
    range). The quesiton of the Halting Problem is does there exist a
    Decider that its input -> output map matches the Halting Mapping.

    Since a decider in this case is a Turing Machine, we know that its input
    is a string in a given alphabet, so the question comes, can we alway
    express a Turing Machine as a finite string representation, and the
    answer to that is YES. (Maybe not in all alphabets, but there exist
    alphabets that can express them).

    This is because BY DEFINITON, a Turing Machine has a finite number of
    states, and accepts a tape with a finite alphabet, thus we have a finite
    number of states * a fintie number if symbols at the tape head giving a
    finite number of cases specifying a finite state, a finite symbol, and a
    binary tape motion. This is thus expressable in a finite string.

    Thus we can ALWAYS convert the input to the Halting Mapping into some
    input that FULLY EXPRESSES what the input is, thus there exists machines
    with a range that expresses ALL possible Turing Machine + Input
    possibilities. We actually knew that before from the existence of the
    Universal Turing Machine, which takes as its input such a description.

    Thus, if a given machine can't "understand" its input as such a machine
    in some cases, the error is in that particular machine, not the
    specification.

    Now, yes, it is still possible that no machine can actually compute such
    a mapping, but that is the question itself. Your error is you seem to be presuming that the definition of a Halt Decider requires that such a
    machine actually exist, which it doesn't.

    It is the same as you idea that the Truth of a statement requires that a
    Proof or Refutation exist, which it doesn't. (We are allowed to have
    Unknown and even Unknowable Truths).

    There is no conflict, just the fact that such a machine can not exist.


    You are just proving that you don't understand the nature of logic, or
    of Truth.

    The Halting Problem STARTS with some arbitrary program. If that
    program can't be specified to the "decider", then the decider just
    fails to be an answer to the Halting Problem.

    Otherwise, I can trivially write a "correct" halt decider by just
    defining that it can accept a very limited set of encoded programs
    (like none with backward jumps), and then I can easily decide if they
    will halt or not.

    This example shows the incorrectness of YOUR (false) definition.

    You just continue to prove your ignorance of the field.



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Sat May 14 11:52:53 2022
    XPost: comp.theory, sci.logic

    On 5/14/2022 10:33 AM, Richard Damon wrote:
    On 5/14/22 10:53 AM, olcott wrote:
    On 5/14/2022 9:31 AM, Richard Damon wrote:
    On 5/14/22 10:00 AM, olcott wrote:
    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong
    because
    it contradicts the definition of a computer science decider in some >>>>>> rare cases that no one never noticed before.

    Well that's pretty clear.  The halting problem, as defined by everyone >>>>> by you (i.e. about which computations are finite and which are not) is >>>>> indeed undecidable.


    Not at all. We must simply correct the error of the halting problem
    definition so that it does not diverge from the definition of a
    decider thus causes it to diverge from the definition of a computation. >>>>
    You are even (almost) correct about the halting theorem.  The two
    notions of "computation" and "halt decider", as conventionally
    defined,
    are contradictory.


    *The corrected halting problem definition*
    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 *specified by this description* will
    finish running,  or continue to run forever.
    https://en.wikipedia.org/wiki/Halting_problem



    WRONG, you don't get to change the definition of the Problem.


    [ computer science is inconsistent ]
    If two definitions within computer science contradict each other then
    computer science itself is an inconsistent system thus conclusively
    proving that computer science diverges from correct reasoning.

    If all halt deciders must compute the mapping from their inputs to an
    accept/reject state on the basis of the actual behavior that this
    input actually specifies and the halting problem specifies that a halt
    decider must compute the mapping from non-inputs, then one of these
    two must go or computer science remains inconsistent.

    learned-by-rote people that only know things by-the-book tend to take
    the gospel of textbooks as holy words contradictions and all.

    Like with religious people they tend to believe that the
    contradictions are somehow resolved at a level higher than their
    current understanding.

    Except that you are ignoring that the definitions are NOT inconsistent, unless you require that Halting be computable.


    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return the corresponding output. https://en.wikipedia.org/wiki/Computable_function

    The halting criteria are defined such that they diverge from the
    definition of a decider and they also diverge form the definition of a computable function in some rare cases. In these cases the halting
    criteria are incorrect.

    The Halting Mapping of Turing Machines is well defined, as a mapping of
    a Turing Machine + finite String Input -> { Halting, Non-Halting} based
    on if the Turing Machine will reach a final state in any finite number
    of steps, or never reach such a final state after an unbounded number of step.


    It must be the actual behavior actually specified by the inputs and
    cannot be the behavior specified by non-inputs unless this behavior is identical to the behavior of the inputs.

    It has previously simply always been (incorrectly) assumed to be the
    case that the behavior specified by the inputs cannot possibly diverge
    from the behavior of their direct execution.

    In those cases where the actual behavior of the actual input to H(P,P)
    is not identical to the behavior of the direct execution of P(P) the
    definition of the halting criteria directly contradicts the definition
    of a decider and the definition of a computation, thus invalidating it.

    Right? That is a very straight forward definition, and all Inputs have a
    well defined and definite output. No Machine + Input can do both be
    Halting and Non-Halting, or fail to be at least one of Halting or Non-Halting. (Either then number of steps processed halts at a finite
    number in a final state or counts to an unbounded number).

    A Decider, always maps an input (in its domain) to an output (in its
    range). The quesiton of the Halting Problem is does there exist a
    Decider that its input -> output map matches the Halting Mapping.

    Since a decider in this case is a Turing Machine, we know that its input
    is a string in a given alphabet, so the question comes, can we alway
    express a Turing Machine as a finite string representation, and the
    answer to that is YES. (Maybe not in all alphabets, but there exist
    alphabets that can express them).

    This is because BY DEFINITON, a Turing Machine has a finite number of
    states, and accepts a tape with a finite alphabet, thus we have a finite number of states * a fintie number if symbols at the tape head giving a finite number of cases specifying a finite state, a finite symbol, and a binary tape motion. This is thus expressable in a finite string.

    Thus we can ALWAYS convert the input to the Halting Mapping into some
    input that FULLY EXPRESSES what the input is, thus there exists machines
    with a range that expresses ALL possible Turing Machine + Input possibilities. We actually knew that before from the existence of the Universal Turing Machine, which takes as its input such a description.

    Thus, if a given machine can't "understand" its input as such a machine
    in some cases, the error is in that particular machine, not the specification.

    Now, yes, it is still possible that no machine can actually compute such
    a mapping, but that is the question itself. Your error is you seem to be presuming that the definition of a Halt Decider requires that such a
    machine actually exist, which it doesn't.

    It is the same as you idea that the Truth of a statement requires that a Proof or Refutation exist, which it doesn't. (We are allowed to have
    Unknown and even Unknowable Truths).

    There is no conflict, just the fact that such a machine can not exist.


    You are just proving that you don't understand the nature of logic,
    or of Truth.

    The Halting Problem STARTS with some arbitrary program. If that
    program can't be specified to the "decider", then the decider just
    fails to be an answer to the Halting Problem.

    Otherwise, I can trivially write a "correct" halt decider by just
    defining that it can accept a very limited set of encoded programs
    (like none with backward jumps), and then I can easily decide if they
    will halt or not.

    This example shows the incorrectness of YOUR (false) definition.

    You just continue to prove your ignorance of the field.





    --
    Copyright 2022 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 Richard Damon@21:1/5 to olcott on Sat May 14 17:28:10 2022
    XPost: comp.theory, sci.logic

    On 5/14/22 12:52 PM, olcott wrote:
    On 5/14/2022 10:33 AM, Richard Damon wrote:
    On 5/14/22 10:53 AM, olcott wrote:
    On 5/14/2022 9:31 AM, Richard Damon wrote:
    On 5/14/22 10:00 AM, olcott wrote:
    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong
    because
    it contradicts the definition of a computer science decider in some >>>>>>> rare cases that no one never noticed before.

    Well that's pretty clear.  The halting problem, as defined by
    everyone
    by you (i.e. about which computations are finite and which are
    not) is
    indeed undecidable.


    Not at all. We must simply correct the error of the halting problem
    definition so that it does not diverge from the definition of a
    decider thus causes it to diverge from the definition of a
    computation.

    You are even (almost) correct about the halting theorem.  The two >>>>>> notions of "computation" and "halt decider", as conventionally
    defined,
    are contradictory.


    *The corrected halting problem definition*
    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 *specified by this description*
    will finish running,  or continue to run forever.
    https://en.wikipedia.org/wiki/Halting_problem



    WRONG, you don't get to change the definition of the Problem.


    [ computer science is inconsistent ]
    If two definitions within computer science contradict each other then
    computer science itself is an inconsistent system thus conclusively
    proving that computer science diverges from correct reasoning.

    If all halt deciders must compute the mapping from their inputs to an
    accept/reject state on the basis of the actual behavior that this
    input actually specifies and the halting problem specifies that a
    halt decider must compute the mapping from non-inputs, then one of
    these two must go or computer science remains inconsistent.

    learned-by-rote people that only know things by-the-book tend to take
    the gospel of textbooks as holy words contradictions and all.

    Like with religious people they tend to believe that the
    contradictions are somehow resolved at a level higher than their
    current understanding.

    Except that you are ignoring that the definitions are NOT
    inconsistent, unless you require that Halting be computable.


    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return the corresponding output. https://en.wikipedia.org/wiki/Computable_function

    The halting criteria are defined such that they diverge from the
    definition of a decider and they also diverge form the definition of a computable function in some rare cases. In these cases the halting
    criteria are incorrect.

    You just don't understand do you. The Halting Criteria is NOT defined as
    a "Computable Function", so can't be in conflict with the definition of
    a decider. In fact, the question is "Is the Halting Function
    Commputable?" This means that if the definition of the Halting Criteria
    is incompatible with making a computation from it, we get the simple
    answer of "No, the Halting Function is not computable"

    You don't seem to understnad that not all functions are computatable,
    and that for those that answer to the question of can you make a Turing
    Machine compute them is just "No".


    The Halting Mapping of Turing Machines is well defined, as a mapping
    of a Turing Machine + finite String Input -> { Halting, Non-Halting}
    based on if the Turing Machine will reach a final state in any finite
    number of steps, or never reach such a final state after an unbounded
    number of step.


    It must be the actual behavior actually specified by the inputs and
    cannot be the behavior specified by non-inputs unless this behavior is identical to the behavior of the inputs.

    Right, and since the input specifies all the details of the Turing
    Machine in question, the "behavior" of that input relates to that machine.

    That IS the input, not a non-input. In fact, YOUR example asks about a non-input, as P calls H which isn't provided in the input, and thus it
    is invalid for your H to answer about that behavior.



    It has previously simply always been (incorrectly) assumed to be the
    case that the behavior specified by the inputs cannot possibly diverge
    from the behavior of their direct execution.

    Because BY DEFINITION, it CAN'T, or the decider doesn't meet the
    requriements.


    In those cases where the actual behavior of the actual input to H(P,P)
    is not identical to the behavior of the direct execution of P(P) the definition of the halting criteria directly contradicts the definition
    of a decider and the definition of a computation, thus invalidating it.

    Nope, it proves that your H fails to meet the requriements. After all,
    the input DOES specify the behavior being asked about, if it was
    constructed correctly as a representation of the machine in question.

    Thus any error is on the decider or the person who designed it and the representation specification.

    Note, DEFINITIONS CAN NOT BE INVALID.

    There is no contradiction between the definition of a decider and the
    Halting Problem, only the fact that no decider can exist that meets the requirements

    If you can't handle that, then that is YOUR problem, not the logic systems.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Sat May 14 16:53:26 2022
    XPost: comp.theory, sci.logic

    On 5/14/2022 4:28 PM, Richard Damon wrote:

    On 5/14/22 12:52 PM, olcott wrote:
    On 5/14/2022 10:33 AM, Richard Damon wrote:
    On 5/14/22 10:53 AM, olcott wrote:
    On 5/14/2022 9:31 AM, Richard Damon wrote:
    On 5/14/22 10:00 AM, olcott wrote:
    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong >>>>>>>> because
    it contradicts the definition of a computer science decider in some >>>>>>>> rare cases that no one never noticed before.

    Well that's pretty clear.  The halting problem, as defined by
    everyone
    by you (i.e. about which computations are finite and which are
    not) is
    indeed undecidable.


    Not at all. We must simply correct the error of the halting
    problem definition so that it does not diverge from the definition >>>>>> of a decider thus causes it to diverge from the definition of a
    computation.

    You are even (almost) correct about the halting theorem.  The two >>>>>>> notions of "computation" and "halt decider", as conventionally
    defined,
    are contradictory.


    *The corrected halting problem definition*
    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 *specified by this description*
    will finish running,  or continue to run forever.
    https://en.wikipedia.org/wiki/Halting_problem



    WRONG, you don't get to change the definition of the Problem.


    [ computer science is inconsistent ]
    If two definitions within computer science contradict each other
    then computer science itself is an inconsistent system thus
    conclusively proving that computer science diverges from correct
    reasoning.

    If all halt deciders must compute the mapping from their inputs to
    an accept/reject state on the basis of the actual behavior that this
    input actually specifies and the halting problem specifies that a
    halt decider must compute the mapping from non-inputs, then one of
    these two must go or computer science remains inconsistent.

    learned-by-rote people that only know things by-the-book tend to
    take the gospel of textbooks as holy words contradictions and all.

    Like with religious people they tend to believe that the
    contradictions are somehow resolved at a level higher than their
    current understanding.

    Except that you are ignoring that the definitions are NOT
    inconsistent, unless you require that Halting be computable.


    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return the
    corresponding output. https://en.wikipedia.org/wiki/Computable_function

    The halting criteria are defined such that they diverge from the
    definition of a decider and they also diverge form the definition of a
    computable function in some rare cases. In these cases the halting
    criteria are incorrect.

    You just don't understand do you. The Halting Criteria is NOT defined as
    a "Computable Function", so can't be in conflict with the definition of
    a decider.

    So in this same way we can make another undecidable problem in computer science: there is no "box of oreos" in computer science that can compute
    the length of a finite string in the same way that there is no
    non-computation that can compute halting.

    In fact, the question is "Is the Halting Function
    Commputable?" This means that if the definition of the Halting Criteria
    is incompatible with making a computation from it, we get the simple
    answer of "No, the Halting Function is not computable"

    You don't seem to understnad that not all functions are computatable,
    and that for those that answer to the question of can you make a Turing Machine compute them is just "No".


    The Halting Mapping of Turing Machines is well defined, as a mapping
    of a Turing Machine + finite String Input -> { Halting, Non-Halting}
    based on if the Turing Machine will reach a final state in any finite
    number of steps, or never reach such a final state after an unbounded
    number of step.


    It must be the actual behavior actually specified by the inputs and
    cannot be the behavior specified by non-inputs unless this behavior is
    identical to the behavior of the inputs.

    Right, and since the input specifies all the details of the Turing
    Machine in question, the "behavior" of that input relates to that machine.

    That IS the input, not a non-input. In fact, YOUR example asks about a non-input, as P calls H which isn't provided in the input, and thus it
    is invalid for your H to answer about that behavior.



    It has previously simply always been (incorrectly) assumed to be the
    case that the behavior specified by the inputs cannot possibly diverge
    from the behavior of their direct execution.

    Because BY DEFINITION, it CAN'T, or the decider doesn't meet the requriements.


    In those cases where the actual behavior of the actual input to H(P,P)
    is not identical to the behavior of the direct execution of P(P) the
    definition of the halting criteria directly contradicts the definition
    of a decider and the definition of a computation, thus invalidating it.

    Nope, it proves that your H fails to meet the requriements. After all,
    the input DOES specify the behavior being asked about, if it was
    constructed correctly as a representation of the machine in question.

    Thus any error is on the decider or the person who designed it and the representation specification.

    Note, DEFINITIONS CAN NOT BE INVALID.

    There is no contradiction between the definition of a decider and the
    Halting Problem, only the fact that no decider can exist that meets the requirements

    If you can't handle that, then that is YOUR problem, not the logic systems.


    --
    Copyright 2022 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 Richard Damon@21:1/5 to olcott on Sat May 14 18:56:27 2022
    XPost: comp.theory, sci.logic

    On 5/14/22 5:53 PM, olcott wrote:
    On 5/14/2022 4:28 PM, Richard Damon wrote:

    On 5/14/22 12:52 PM, olcott wrote:
    On 5/14/2022 10:33 AM, Richard Damon wrote:
    On 5/14/22 10:53 AM, olcott wrote:
    On 5/14/2022 9:31 AM, Richard Damon wrote:
    On 5/14/22 10:00 AM, olcott wrote:
    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong >>>>>>>>> because
    it contradicts the definition of a computer science decider in >>>>>>>>> some
    rare cases that no one never noticed before.

    Well that's pretty clear.  The halting problem, as defined by >>>>>>>> everyone
    by you (i.e. about which computations are finite and which are >>>>>>>> not) is
    indeed undecidable.


    Not at all. We must simply correct the error of the halting
    problem definition so that it does not diverge from the
    definition of a decider thus causes it to diverge from the
    definition of a computation.

    You are even (almost) correct about the halting theorem.  The two >>>>>>>> notions of "computation" and "halt decider", as conventionally >>>>>>>> defined,
    are contradictory.


    *The corrected halting problem definition*
    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 *specified by this description* >>>>>>> will finish running,  or continue to run forever.
    https://en.wikipedia.org/wiki/Halting_problem



    WRONG, you don't get to change the definition of the Problem.


    [ computer science is inconsistent ]
    If two definitions within computer science contradict each other
    then computer science itself is an inconsistent system thus
    conclusively proving that computer science diverges from correct
    reasoning.

    If all halt deciders must compute the mapping from their inputs to
    an accept/reject state on the basis of the actual behavior that
    this input actually specifies and the halting problem specifies
    that a halt decider must compute the mapping from non-inputs, then
    one of these two must go or computer science remains inconsistent.

    learned-by-rote people that only know things by-the-book tend to
    take the gospel of textbooks as holy words contradictions and all.

    Like with religious people they tend to believe that the
    contradictions are somehow resolved at a level higher than their
    current understanding.

    Except that you are ignoring that the definitions are NOT
    inconsistent, unless you require that Halting be computable.


    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return
    the corresponding output.
    https://en.wikipedia.org/wiki/Computable_function

    The halting criteria are defined such that they diverge from the
    definition of a decider and they also diverge form the definition of
    a computable function in some rare cases. In these cases the halting
    criteria are incorrect.

    You just don't understand do you. The Halting Criteria is NOT defined
    as a "Computable Function", so can't be in conflict with the
    definition of a decider.

    So in this same way we can make another undecidable problem in computer science: there is no "box of oreos" in computer science that can compute
    the length of a finite string in the same way that there is no non-computation that can compute halting.

    Another of your famous nonsensical diversions. Since there IS NO "box of
    oreos" in Computer Science, you just committed another category error
    proving you don't know what you are talking about.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat May 14 19:53:06 2022
    XPost: comp.theory, sci.logic

    On 5/14/22 7:33 PM, olcott wrote:
    On 5/14/2022 5:56 PM, Richard Damon wrote:
    On 5/14/22 5:53 PM, olcott wrote:
    On 5/14/2022 4:28 PM, Richard Damon wrote:

    On 5/14/22 12:52 PM, olcott wrote:
    On 5/14/2022 10:33 AM, Richard Damon wrote:
    On 5/14/22 10:53 AM, olcott wrote:
    On 5/14/2022 9:31 AM, Richard Damon wrote:
    On 5/14/22 10:00 AM, olcott wrote:
    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is >>>>>>>>>>> wrong because
    it contradicts the definition of a computer science decider >>>>>>>>>>> in some
    rare cases that no one never noticed before.

    Well that's pretty clear.  The halting problem, as defined by >>>>>>>>>> everyone
    by you (i.e. about which computations are finite and which are >>>>>>>>>> not) is
    indeed undecidable.


    Not at all. We must simply correct the error of the halting
    problem definition so that it does not diverge from the
    definition of a decider thus causes it to diverge from the
    definition of a computation.

    You are even (almost) correct about the halting theorem.  The two >>>>>>>>>> notions of "computation" and "halt decider", as conventionally >>>>>>>>>> defined,
    are contradictory.


    *The corrected halting problem definition*
    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 *specified by this >>>>>>>>> description* will finish running,  or continue to run forever. >>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem



    WRONG, you don't get to change the definition of the Problem.


    [ computer science is inconsistent ]
    If two definitions within computer science contradict each other >>>>>>> then computer science itself is an inconsistent system thus
    conclusively proving that computer science diverges from correct >>>>>>> reasoning.

    If all halt deciders must compute the mapping from their inputs
    to an accept/reject state on the basis of the actual behavior
    that this input actually specifies and the halting problem
    specifies that a halt decider must compute the mapping from
    non-inputs, then one of these two must go or computer science
    remains inconsistent.

    learned-by-rote people that only know things by-the-book tend to >>>>>>> take the gospel of textbooks as holy words contradictions and all. >>>>>>>
    Like with religious people they tend to believe that the
    contradictions are somehow resolved at a level higher than their >>>>>>> current understanding.

    Except that you are ignoring that the definitions are NOT
    inconsistent, unless you require that Halting be computable.


    Computable functions are the basic objects of study in
    computability theory. Computable functions are the formalized
    analogue of the intuitive notion of algorithms, in the sense that a
    function is computable if there exists an algorithm that can do the
    job of the function, i.e. given an input of the function domain it
    can return the corresponding output.
    https://en.wikipedia.org/wiki/Computable_function

    The halting criteria are defined such that they diverge from the
    definition of a decider and they also diverge form the definition
    of a computable function in some rare cases. In these cases the
    halting criteria are incorrect.

    You just don't understand do you. The Halting Criteria is NOT
    defined as a "Computable Function", so can't be in conflict with the
    definition of a decider.

    So in this same way we can make another undecidable problem in
    computer science: there is no "box of oreos" in computer science that
    can compute the length of a finite string in the same way that there
    is no non-computation that can compute halting.

    Another of your famous nonsensical diversions. Since there IS NO "box
    of oreos" in Computer Science, you just committed another category
    error proving you don't know what you are talking about.

    In this same way requiring a non-computation to compute is an incorrect problem definition.


    Nope, just you making Herring in Red sauce.

    You are just proving your ignorance.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Sat May 14 18:33:09 2022
    XPost: comp.theory, sci.logic

    On 5/14/2022 5:56 PM, Richard Damon wrote:
    On 5/14/22 5:53 PM, olcott wrote:
    On 5/14/2022 4:28 PM, Richard Damon wrote:

    On 5/14/22 12:52 PM, olcott wrote:
    On 5/14/2022 10:33 AM, Richard Damon wrote:
    On 5/14/22 10:53 AM, olcott wrote:
    On 5/14/2022 9:31 AM, Richard Damon wrote:
    On 5/14/22 10:00 AM, olcott wrote:
    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong >>>>>>>>>> because
    it contradicts the definition of a computer science decider in >>>>>>>>>> some
    rare cases that no one never noticed before.

    Well that's pretty clear.  The halting problem, as defined by >>>>>>>>> everyone
    by you (i.e. about which computations are finite and which are >>>>>>>>> not) is
    indeed undecidable.


    Not at all. We must simply correct the error of the halting
    problem definition so that it does not diverge from the
    definition of a decider thus causes it to diverge from the
    definition of a computation.

    You are even (almost) correct about the halting theorem.  The two >>>>>>>>> notions of "computation" and "halt decider", as conventionally >>>>>>>>> defined,
    are contradictory.


    *The corrected halting problem definition*
    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 *specified by this
    description* will finish running,  or continue to run forever. >>>>>>>> https://en.wikipedia.org/wiki/Halting_problem



    WRONG, you don't get to change the definition of the Problem.


    [ computer science is inconsistent ]
    If two definitions within computer science contradict each other
    then computer science itself is an inconsistent system thus
    conclusively proving that computer science diverges from correct
    reasoning.

    If all halt deciders must compute the mapping from their inputs to >>>>>> an accept/reject state on the basis of the actual behavior that
    this input actually specifies and the halting problem specifies
    that a halt decider must compute the mapping from non-inputs, then >>>>>> one of these two must go or computer science remains inconsistent. >>>>>>
    learned-by-rote people that only know things by-the-book tend to
    take the gospel of textbooks as holy words contradictions and all. >>>>>>
    Like with religious people they tend to believe that the
    contradictions are somehow resolved at a level higher than their
    current understanding.

    Except that you are ignoring that the definitions are NOT
    inconsistent, unless you require that Halting be computable.


    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return
    the corresponding output.
    https://en.wikipedia.org/wiki/Computable_function

    The halting criteria are defined such that they diverge from the
    definition of a decider and they also diverge form the definition of
    a computable function in some rare cases. In these cases the halting
    criteria are incorrect.

    You just don't understand do you. The Halting Criteria is NOT defined
    as a "Computable Function", so can't be in conflict with the
    definition of a decider.

    So in this same way we can make another undecidable problem in
    computer science: there is no "box of oreos" in computer science that
    can compute the length of a finite string in the same way that there
    is no non-computation that can compute halting.

    Another of your famous nonsensical diversions. Since there IS NO "box of oreos" in Computer Science, you just committed another category error
    proving you don't know what you are talking about.

    In this same way requiring a non-computation to compute is an incorrect
    problem definition.

    --
    Copyright 2022 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 on Tue May 17 22:02:47 2022
    XPost: comp.theory, sci.logic

    On 5/15/2022 7:18 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 6:20 PM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong because >>>>>> it contradicts the definition of a computer science decider in some >>>>>> rare cases that no one never noticed before.
    Well that's pretty clear. The halting problem, as defined by everyone >>>>> by you (i.e. about which computations are finite and which are not) is >>>>> indeed undecidable.

    Not at all.
    So you believe it is possible for a function D to be written such that
    D(X,Y) == true if and only of X(Y) halts and false otherwise?

    In the same way that a TM can use a "box of oreos" to compute the
    length of a finite string a non-computation can compute the halt
    status of a non-input.

    The HP is defined incorrectly. It cannot be about computations, it
    must be about the computations that inputs specify.

    The two pointers X and Y can be taken to specify a function call X(Y).

    Not when they are correctly simulated by H.

    That's what they specify in the call D(X,Y) that you are trying so hard
    to avoid taking about. What you take them to specify in a call to your
    H is not interesting.

    Your H is boring because "the computations that input specify" are so limited. Many simple computations consisting of one pointer called with
    the other as an argument can't be specified at all (apparently) so you
    should probably stop wasting time on your H.

    Either there can be a function D such that D(X,Y) == false if and only
    of the computation, X(Y), specified by those "inputs" does not halt, or
    there can't be. But even after 18 years of what you call "research" you won't dare hazard a guess about the possible existence of such an
    important algorithm!

    You continue to push the nutty idea that the halt decider is required to "compute" on non-computation.

    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return the corresponding output. https://en.wikipedia.org/wiki/Computable_function




    --
    Copyright 2022 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 Richard Damon@21:1/5 to olcott on Wed May 18 08:27:29 2022
    XPost: comp.theory, sci.logic

    On 5/17/22 11:02 PM, olcott wrote:
    On 5/15/2022 7:18 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 6:20 PM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong
    because
    it contradicts the definition of a computer science decider in some >>>>>>> rare cases that no one never noticed before.
    Well that's pretty clear.  The halting problem, as defined by
    everyone
    by you (i.e. about which computations are finite and which are
    not) is
    indeed undecidable.

    Not at all.
    So you believe it is possible for a function D to be written such that >>>> D(X,Y) == true if and only of X(Y) halts and false otherwise?

    In the same way that a TM can use a "box of oreos" to compute the
    length of a finite string a non-computation can compute the halt
    status of a non-input.

    The HP is defined incorrectly. It cannot be about computations, it
    must be about the computations that inputs specify.

    The two pointers X and Y can be taken to specify a function call X(Y).

    Not when they are correctly simulated by H.

    That's what they specify in the call D(X,Y) that you are trying so hard
    to avoid taking about.  What you take them to specify in a call to your
    H is not interesting.

    Your H is boring because "the computations that input specify" are so
    limited.  Many simple computations consisting of one pointer called with
    the other as an argument can't be specified at all (apparently) so you
    should probably stop wasting time on your H.

    Either there can be a function D such that D(X,Y) == false if and only
    of the computation, X(Y), specified by those "inputs" does not halt, or
    there can't be.  But even after 18 years of what you call "research" you
    won't dare hazard a guess about the possible existence of such an
    important algorithm!

    You continue to push the nutty idea that the halt decider is required to "compute" on non-computation.

    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return the corresponding output. https://en.wikipedia.org/wiki/Computable_function





    If H^ is not a computation, then H isn't either.

    You are just proving that you don't understand what this topic is about.

    It has been shown that you can convert ANY Turing Machine to a
    representation, and the input to H is defined as a Representation of a
    Turing Machine.

    If you arguement is that you can't decide on the behavior of a Turing
    Machine just from a representation of it as a computation, then you are
    just agreeing that the Halting Problem IS impossible to "Compute" even
    if you don't understand that is what you are saying.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Wed May 18 10:37:09 2022
    XPost: comp.theory, sci.logic

    On 5/18/2022 7:27 AM, Richard Damon wrote:
    On 5/17/22 11:02 PM, olcott wrote:
    On 5/15/2022 7:18 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 6:20 PM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong >>>>>>>> because
    it contradicts the definition of a computer science decider in some >>>>>>>> rare cases that no one never noticed before.
    Well that's pretty clear.  The halting problem, as defined by
    everyone
    by you (i.e. about which computations are finite and which are
    not) is
    indeed undecidable.

    Not at all.
    So you believe it is possible for a function D to be written such that >>>>> D(X,Y) == true if and only of X(Y) halts and false otherwise?

    In the same way that a TM can use a "box of oreos" to compute the
    length of a finite string a non-computation can compute the halt
    status of a non-input.

    The HP is defined incorrectly. It cannot be about computations, it
    must be about the computations that inputs specify.

    The two pointers X and Y can be taken to specify a function call X(Y).

    Not when they are correctly simulated by H.

    That's what they specify in the call D(X,Y) that you are trying so hard
    to avoid taking about.  What you take them to specify in a call to your >>> H is not interesting.

    Your H is boring because "the computations that input specify" are so
    limited.  Many simple computations consisting of one pointer called with >>> the other as an argument can't be specified at all (apparently) so you
    should probably stop wasting time on your H.

    Either there can be a function D such that D(X,Y) == false if and only
    of the computation, X(Y), specified by those "inputs" does not halt, or
    there can't be.  But even after 18 years of what you call "research" you >>> won't dare hazard a guess about the possible existence of such an
    important algorithm!

    You continue to push the nutty idea that the halt decider is required to
    "compute" on non-computation.

    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return the
    corresponding output. https://en.wikipedia.org/wiki/Computable_function





    If H^ is not a computation, then H isn't either.


    H(P,P)==0 is a correct computation.

    You are just proving that you don't understand what this topic is about.

    It has been shown that you can convert ANY Turing Machine to a representation, and the input to H is defined as a Representation of a
    Turing Machine.


    int sum(int x, int y)
    {
    return x + y;
    }


    H(P,P) (a dependent computation) cannot report on P(P) an independent computation in the same way that sum(3,4) cannot report on sum(8,7).

    If you arguement is that you can't decide on the behavior of a Turing
    Machine just from a representation of it as a computation, then you are
    just agreeing that the Halting Problem IS impossible to "Compute" even
    if you don't understand that is what you are saying.


    --
    Copyright 2022 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 Ben@21:1/5 to olcott on Wed May 18 16:20:16 2022
    XPost: comp.theory, sci.logic

    olcott <NoOne@NoWhere.com> writes:

    On 5/15/2022 7:18 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 6:20 PM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong because >>>>>>> it contradicts the definition of a computer science decider in some >>>>>>> rare cases that no one never noticed before.
    Well that's pretty clear. The halting problem, as defined by everyone >>>>>> by you (i.e. about which computations are finite and which are not) is >>>>>> indeed undecidable.

    Not at all.
    So you believe it is possible for a function D to be written such that >>>> D(X,Y) == true if and only of X(Y) halts and false otherwise?

    In the same way that a TM can use a "box of oreos" to compute the
    length of a finite string a non-computation can compute the halt
    status of a non-input.

    The HP is defined incorrectly. It cannot be about computations, it
    must be about the computations that inputs specify.

    The two pointers X and Y can be taken to specify a function call X(Y).

    Not when they are correctly simulated by H.

    Then H is not a halt decider:

    That's what they specify in the call D(X,Y) that you are trying so hard
    to avoid taking about.

    You continue to push the nutty idea that the halt decider is required to "compute" on non-computation.

    X(Y) is a computation entirely determined by the data to be found at X
    and Y (and possibly by following further links from that data). The two "input" pointers specify, without any ambiguity, the computation that D
    is supposed to tell up about (and which you now accept, albeit
    implicitly, that it can't).

    No one cares about anything else that can be determined by examining X
    and Y other than whether the call X(Y) is finite or not. At least you
    are now 100% clear that H is not deciding anything we care about.

    --
    Ben.
    "le génie humain a des limites, quand la bêtise humaine n’en a pas" Alexandre Dumas (fils)

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Wed May 18 19:09:09 2022
    XPost: comp.theory, sci.logic

    On 5/18/22 11:37 AM, olcott wrote:
    On 5/18/2022 7:27 AM, Richard Damon wrote:
    On 5/17/22 11:02 PM, olcott wrote:
    On 5/15/2022 7:18 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 6:20 PM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong >>>>>>>>> because
    it contradicts the definition of a computer science decider in >>>>>>>>> some
    rare cases that no one never noticed before.
    Well that's pretty clear.  The halting problem, as defined by >>>>>>>> everyone
    by you (i.e. about which computations are finite and which are >>>>>>>> not) is
    indeed undecidable.

    Not at all.
    So you believe it is possible for a function D to be written such
    that
    D(X,Y) == true if and only of X(Y) halts and false otherwise?

    In the same way that a TM can use a "box of oreos" to compute the
    length of a finite string a non-computation can compute the halt
    status of a non-input.

    The HP is defined incorrectly. It cannot be about computations, it
    must be about the computations that inputs specify.

    The two pointers X and Y can be taken to specify a function call X(Y).

    Not when they are correctly simulated by H.

    That's what they specify in the call D(X,Y) that you are trying so hard >>>> to avoid taking about.  What you take them to specify in a call to your >>>> H is not interesting.

    Your H is boring because "the computations that input specify" are so
    limited.  Many simple computations consisting of one pointer called
    with
    the other as an argument can't be specified at all (apparently) so you >>>> should probably stop wasting time on your H.

    Either there can be a function D such that D(X,Y) == false if and only >>>> of the computation, X(Y), specified by those "inputs" does not halt, or >>>> there can't be.  But even after 18 years of what you call "research"
    you
    won't dare hazard a guess about the possible existence of such an
    important algorithm!

    You continue to push the nutty idea that the halt decider is required to >>> "compute" on non-computation.

    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return
    the corresponding output.
    https://en.wikipedia.org/wiki/Computable_function





    If H^ is not a computation, then H isn't either.


    H(P,P)==0 is a correct computation.

    Only if H isn't a Halting Decider.

    Since P(P) halts when H(P,P) is 0, it CAN'T be correct.

    DEFINITION.


    You are just proving that you don't understand what this topic is about.

    It has been shown that you can convert ANY Turing Machine to a
    representation, and the input to H is defined as a Representation of a
    Turing Machine.


    int sum(int x, int y)
    {
      return x + y;
    }


    H(P,P) (a dependent computation) cannot report on P(P) an independent computation in the same way that sum(3,4) cannot report on sum(8,7).

    So you ADMIT that there is a compuation that H can't give the answer to
    the Halting Problem?

    That just PROVES the Theorem you are trying to disprove.


    If you arguement is that you can't decide on the behavior of a Turing
    Machine just from a representation of it as a computation, then you
    are just agreeing that the Halting Problem IS impossible to "Compute"
    even if you don't understand that is what you are saying.



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Wed May 18 18:35:33 2022
    XPost: comp.theory, sci.logic

    On 5/18/2022 6:09 PM, Richard Damon wrote:
    On 5/18/22 11:37 AM, olcott wrote:
    On 5/18/2022 7:27 AM, Richard Damon wrote:
    On 5/17/22 11:02 PM, olcott wrote:
    On 5/15/2022 7:18 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 6:20 PM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is wrong >>>>>>>>>> because
    it contradicts the definition of a computer science decider in >>>>>>>>>> some
    rare cases that no one never noticed before.
    Well that's pretty clear.  The halting problem, as defined by >>>>>>>>> everyone
    by you (i.e. about which computations are finite and which are >>>>>>>>> not) is
    indeed undecidable.

    Not at all.
    So you believe it is possible for a function D to be written such >>>>>>> that
    D(X,Y) == true if and only of X(Y) halts and false otherwise?

    In the same way that a TM can use a "box of oreos" to compute the
    length of a finite string a non-computation can compute the halt
    status of a non-input.

    The HP is defined incorrectly. It cannot be about computations, it >>>>>> must be about the computations that inputs specify.

    The two pointers X and Y can be taken to specify a function call X(Y). >>>>
    Not when they are correctly simulated by H.

    That's what they specify in the call D(X,Y) that you are trying so
    hard
    to avoid taking about.  What you take them to specify in a call to
    your
    H is not interesting.

    Your H is boring because "the computations that input specify" are so >>>>> limited.  Many simple computations consisting of one pointer called >>>>> with
    the other as an argument can't be specified at all (apparently) so you >>>>> should probably stop wasting time on your H.

    Either there can be a function D such that D(X,Y) == false if and only >>>>> of the computation, X(Y), specified by those "inputs" does not
    halt, or
    there can't be.  But even after 18 years of what you call
    "research" you
    won't dare hazard a guess about the possible existence of such an
    important algorithm!

    You continue to push the nutty idea that the halt decider is
    required to
    "compute" on non-computation.

    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. given an input of the function domain it can return
    the corresponding output.
    https://en.wikipedia.org/wiki/Computable_function





    If H^ is not a computation, then H isn't either.


    H(P,P)==0 is a correct computation.

    Only if H isn't a Halting Decider.


    Your definition of halt decider contradicts the definition of a decider
    and also contradicts the definition of a computation, thus is incorrect.

    When we restrict the definition of a halt decider to a computation then H(P,P)==0 is a correct computation by a decider.

    a function is computable if there exists an algorithm that can do the
    job of the function, i.e. given an input of the function domain it can
    return the corresponding output. https://en.wikipedia.org/wiki/Computable_function

    Since P(P) halts when H(P,P) is 0, it CAN'T be correct.

    DEFINITION.


    You are just proving that you don't understand what this topic is about. >>>
    It has been shown that you can convert ANY Turing Machine to a
    representation, and the input to H is defined as a Representation of
    a Turing Machine.


    int sum(int x, int y)
    {
       return x + y;
    }


    H(P,P) (a dependent computation) cannot report on P(P) an independent
    computation in the same way that sum(3,4) cannot report on sum(8,7).

    So you ADMIT that there is a compuation that H can't give the answer to
    the Halting Problem?

    That just PROVES the Theorem you are trying to disprove.

    If you arguement is that you can't decide on the behavior of a Turing
    Machine just from a representation of it as a computation, then you
    are just agreeing that the Halting Problem IS impossible to "Compute"
    even if you don't understand that is what you are saying.





    --
    Copyright 2022 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 Richard Damon@21:1/5 to olcott on Wed May 18 20:02:46 2022
    XPost: comp.theory, sci.logic

    On 5/18/22 7:35 PM, olcott wrote:
    On 5/18/2022 6:09 PM, Richard Damon wrote:
    On 5/18/22 11:37 AM, olcott wrote:
    On 5/18/2022 7:27 AM, Richard Damon wrote:
    On 5/17/22 11:02 PM, olcott wrote:
    On 5/15/2022 7:18 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 6:20 PM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    On 5/14/2022 3:07 AM, Ben wrote:
    olcott <NoOne@NoWhere.com> writes:

    The halting criteria that the halting problem expects is >>>>>>>>>>> wrong because
    it contradicts the definition of a computer science decider >>>>>>>>>>> in some
    rare cases that no one never noticed before.
    Well that's pretty clear.  The halting problem, as defined by >>>>>>>>>> everyone
    by you (i.e. about which computations are finite and which are >>>>>>>>>> not) is
    indeed undecidable.

    Not at all.
    So you believe it is possible for a function D to be written
    such that
    D(X,Y) == true if and only of X(Y) halts and false otherwise?

    In the same way that a TM can use a "box of oreos" to compute the >>>>>>> length of a finite string a non-computation can compute the halt >>>>>>> status of a non-input.

    The HP is defined incorrectly. It cannot be about computations, it >>>>>>> must be about the computations that inputs specify.

    The two pointers X and Y can be taken to specify a function call
    X(Y).

    Not when they are correctly simulated by H.

    That's what they specify in the call D(X,Y) that you are trying so >>>>>> hard
    to avoid taking about.  What you take them to specify in a call to >>>>>> your
    H is not interesting.

    Your H is boring because "the computations that input specify" are so >>>>>> limited.  Many simple computations consisting of one pointer
    called with
    the other as an argument can't be specified at all (apparently) so >>>>>> you
    should probably stop wasting time on your H.

    Either there can be a function D such that D(X,Y) == false if and
    only
    of the computation, X(Y), specified by those "inputs" does not
    halt, or
    there can't be.  But even after 18 years of what you call
    "research" you
    won't dare hazard a guess about the possible existence of such an
    important algorithm!

    You continue to push the nutty idea that the halt decider is
    required to
    "compute" on non-computation.

    Computable functions are the basic objects of study in
    computability theory. Computable functions are the formalized
    analogue of the intuitive notion of algorithms, in the sense that a
    function is computable if there exists an algorithm that can do the
    job of the function, i.e. given an input of the function domain it
    can return the corresponding output.
    https://en.wikipedia.org/wiki/Computable_function





    If H^ is not a computation, then H isn't either.


    H(P,P)==0 is a correct computation.

    Only if H isn't a Halting Decider.


    Your definition of halt decider contradicts the definition of a decider
    and also contradicts the definition of a computation, thus is incorrect.

    HOW?

    A decider is a computation that halts for all inputs.

    A Computation is a merely a model of calculation based on a well defined algorithm.



    When we restrict the definition of a halt decider to a computation then H(P,P)==0 is a correct computation by a decider.

    But that IS the question, can you actually make a Computation that can
    decide on the Halting Function. You don't get to change the Halting
    Function, you either get to make a Computation/Decider that computes it
    or you admit that it isn't possible.

    THAT IS the question.


    a function is computable if there exists an algorithm that can do the
    job of the function, i.e. given an input of the function domain it can
    return the corresponding output. https://en.wikipedia.org/wiki/Computable_function


    Right, an the question is is that mapping of (M,w) to the Halting Status
    of M applied to w computable.

    If you say it can't be done because that mapping contradicts the meaning
    of a decider/compuation, then the answer is NO, the Halting Function is
    NOT computable.


    Since P(P) halts when H(P,P) is 0, it CAN'T be correct.

    DEFINITION.


    You are just proving that you don't understand what this topic is
    about.

    It has been shown that you can convert ANY Turing Machine to a
    representation, and the input to H is defined as a Representation of
    a Turing Machine.


    int sum(int x, int y)
    {
       return x + y;
    }


    H(P,P) (a dependent computation) cannot report on P(P) an independent
    computation in the same way that sum(3,4) cannot report on sum(8,7).

    So you ADMIT that there is a compuation that H can't give the answer
    to the Halting Problem?

    That just PROVES the Theorem you are trying to disprove.

    Yep, you are just proving that which you try to disprove by your own arguements.

    If we can't even try to define a decider to do the job, then it can't be
    done.

    ;
    If you arguement is that you can't decide on the behavior of a
    Turing Machine just from a representation of it as a computation,
    then you are just agreeing that the Halting Problem IS impossible to
    "Compute" even if you don't understand that is what you are saying.






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