• Simulating halt deciders defeat the halting theorem [ irrefutable reaso

    From olcott@21:1/5 to All on Thu Feb 16 14:24:44 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    int D(int (*x)())
    {
    int Halt_Status = H(x, x);
    if (Halt_Status)
    HERE: goto HERE;
    return Halt_Status;
    }

    int main()
    {
    Output("Input_Halts = ", H(D,D));
    Output("Input_Halts = ", D(D));
    }

    *Here is my current irrefutable reasoning*
    H(D,D) does correctly compute the mapping from its input to its reject
    state on the basis that H correctly predicts that D correctly simulated
    by H would never halt (reach its own "return" statement and terminate normally).

    Everyone attempting to refute the above verified fact either
    uses the strawman deception to change the subject away from
    [D correctly simulated by H]
    or flat out lies about the behavior of
    [D correctly simulated by H]



    *Complete halt deciding system* (Visual Studio Project) https://liarparadox.org/2023_02_07.zip

    *Simulating Halt Deciders Defeat the Halting Theorem* https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem


    --
    Copyright 2023 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 Thu Feb 16 18:51:53 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/16/23 3:24 PM, olcott wrote:
    int D(int (*x)())
    {
      int Halt_Status = H(x, x);
      if (Halt_Status)
        HERE: goto HERE;
      return Halt_Status;
    }

    int main()
    {
      Output("Input_Halts = ", H(D,D));
      Output("Input_Halts = ", D(D));
    }

    *Here is my current irrefutable reasoning*
    H(D,D) does correctly compute the mapping from its input to its reject
    state on the basis that H correctly predicts that D correctly simulated
    by H would never halt (reach its own "return" statement and terminate normally).

    Everyone attempting to refute the above verified fact either
    uses the strawman deception to change the subject away from
    [D correctly simulated by H]
    or flat out lies about the behavior of
    [D correctly simulated by H]



    *Complete halt deciding system* (Visual Studio Project) https://liarparadox.org/2023_02_07.zip

    *Simulating Halt Deciders Defeat the Halting Theorem* https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem


    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.

    D(D) Halts

    H(D,D) says Non-Halting, thus it is NOT a "Correct Halting Decider of Computabilyt Theory", and any claim it is can be clearly seen to be a LIE.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to olcott on Thu Feb 16 20:03:07 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/16/2023 2:24 PM, olcott wrote:
    int D(int (*x)())
    {
      int Halt_Status = H(x, x);
      if (Halt_Status)
        HERE: goto HERE;
      return Halt_Status;
    }

    int main()
    {
      Output("Input_Halts = ", H(D,D));
      Output("Input_Halts = ", D(D));
    }

    *Here is my current irrefutable reasoning*
    H(D,D) does correctly compute the mapping from its input to its reject
    state on the basis that H correctly predicts that D correctly simulated
    by H would never halt (reach its own "return" statement and terminate normally).

    Everyone attempting to refute the above verified fact either
    uses the strawman deception to change the subject away from
    [D correctly simulated by H]
    or flat out lies about the behavior of
    [D correctly simulated by H]



    *Complete halt deciding system* (Visual Studio Project) https://liarparadox.org/2023_02_07.zip

    *Simulating Halt Deciders Defeat the Halting Theorem* https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem


    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.

    And it is universally understood (by the definition of a UTM) that D
    correctly simulated by H necessarily demonstrates the actual behavior
    specified by this input.

    My reviewers already know this... yet disagree with verified facts
    anyway so that they can play trollish head games.



    --
    Copyright 2023 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 Thu Feb 16 21:37:56 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/16/23 9:03 PM, olcott wrote:
    On 2/16/2023 2:24 PM, olcott wrote:
    int D(int (*x)())
    {
       int Halt_Status = H(x, x);
       if (Halt_Status)
         HERE: goto HERE;
       return Halt_Status;
    }

    int main()
    {
       Output("Input_Halts = ", H(D,D));
       Output("Input_Halts = ", D(D));
    }

    *Here is my current irrefutable reasoning*
    H(D,D) does correctly compute the mapping from its input to its reject
    state on the basis that H correctly predicts that D correctly simulated
    by H would never halt (reach its own "return" statement and terminate
    normally).

    Everyone attempting to refute the above verified fact either
    uses the strawman deception to change the subject away from
    [D correctly simulated by H]
    or flat out lies about the behavior of
    [D correctly simulated by H]



    *Complete halt deciding system* (Visual Studio Project)
    https://liarparadox.org/2023_02_07.zip

    *Simulating Halt Deciders Defeat the Halting Theorem*
    https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem


    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.

    And it is universally understood (by the definition of a UTM) that D correctly simulated by H necessarily demonstrates the actual behavior specified by this input.

    And a UTM will ALWAYS continue simulating until it reaches a final state.

    H doesn't do that, so H isn't a UTM, and thus H's simulation can not be
    a substute for the actual execution of the input, or even the UTM
    simulation of the input.


    My reviewers already know this... yet disagree with verified facts
    anyway so that they can play trollish head games.


    No, it is a verified fact that the H that gives an answer is NOT a UTM,
    and thus your claim that you can use its simulation is just a LIE.

    Your continued instance just proves your ignorance.

    The actual VERIIFED FACTS, which even you have agreed to is that D(D)
    will Halt with your H that returns 0, which means non-halting from
    H(D,D), and thus by the definition of a Halt Decider, the correct answer
    is Halting,

    It is also clear that you claims that Non-Halting is a "Correct Answer"
    when you admit that the machine will actually Halt means you are just
    LYING about what you are talking about.

    PERIOD.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to olcott on Fri Feb 17 08:24:23 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/16/2023 8:03 PM, olcott wrote:
    On 2/16/2023 2:24 PM, olcott wrote:
    int D(int (*x)())
    {
       int Halt_Status = H(x, x);
       if (Halt_Status)
         HERE: goto HERE;
       return Halt_Status;
    }

    int main()
    {
       Output("Input_Halts = ", H(D,D));
       Output("Input_Halts = ", D(D));
    }

    *Here is my current irrefutable reasoning*
    H(D,D) does correctly compute the mapping from its input to its reject
    state on the basis that H correctly predicts that D correctly simulated
    by H would never halt (reach its own "return" statement and terminate
    normally).

    Everyone attempting to refute the above verified fact either
    uses the strawman deception to change the subject away from
    [D correctly simulated by H]
    or flat out lies about the behavior of
    [D correctly simulated by H]



    *Complete halt deciding system* (Visual Studio Project)
    https://liarparadox.org/2023_02_07.zip

    *Simulating Halt Deciders Defeat the Halting Theorem*
    https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem


    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.

    And it is universally understood (by the definition of a UTM) that D correctly simulated by H necessarily demonstrates the actual behavior specified by this input.


    Therefore A halt decider H can be based on a UTM such that H continues
    to simulate its input until H correctly determines that D correctly
    simulated by H would never halt.

    Because H is based on a UTM we know that the behavior that H is
    evaluating is the behavior specified by its input.

    --
    Copyright 2023 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 Fri Feb 17 09:42:59 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/17/23 9:24 AM, olcott wrote:
    On 2/16/2023 8:03 PM, olcott wrote:
    On 2/16/2023 2:24 PM, olcott wrote:
    int D(int (*x)())
    {
       int Halt_Status = H(x, x);
       if (Halt_Status)
         HERE: goto HERE;
       return Halt_Status;
    }

    int main()
    {
       Output("Input_Halts = ", H(D,D));
       Output("Input_Halts = ", D(D));
    }

    *Here is my current irrefutable reasoning*
    H(D,D) does correctly compute the mapping from its input to its reject
    state on the basis that H correctly predicts that D correctly simulated
    by H would never halt (reach its own "return" statement and terminate
    normally).

    Everyone attempting to refute the above verified fact either
    uses the strawman deception to change the subject away from
    [D correctly simulated by H]
    or flat out lies about the behavior of
    [D correctly simulated by H]



    *Complete halt deciding system* (Visual Studio Project)
    https://liarparadox.org/2023_02_07.zip

    *Simulating Halt Deciders Defeat the Halting Theorem*
    https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem


    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.

    And it is universally understood (by the definition of a UTM) that D
    correctly simulated by H necessarily demonstrates the actual behavior
    specified by this input.


    Therefore A halt decider H can be based on a UTM such that H continues
    to simulate its input until H correctly determines that D correctly
    simulated by H would never halt.

    Because H is based on a UTM we know that the behavior that H is
    evaluating is the behavior specified by its input.


    Not quite, H could use logic that H simulated its input until H could corredctly determint that D correctly simulated BY A UTM would never halt.

    But, because H isn't a UTM, since it DOES abort its simulation before
    getting to an end, it is an error to assume that H is a UTM, or in
    particular, that D calling H is calling a UTM.

    All you have done is show that you don't understand the basics of
    programming.

    You whole "proof" is based on the LIE that H is just like a UTM, when it
    isn't.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to olcott on Fri Feb 17 09:04:21 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/17/2023 8:24 AM, olcott wrote:
    On 2/16/2023 8:03 PM, olcott wrote:
    On 2/16/2023 2:24 PM, olcott wrote:
    int D(int (*x)())
    {
       int Halt_Status = H(x, x);
       if (Halt_Status)
         HERE: goto HERE;
       return Halt_Status;
    }

    int main()
    {
       Output("Input_Halts = ", H(D,D));
       Output("Input_Halts = ", D(D));
    }

    *Here is my current irrefutable reasoning*
    H(D,D) does correctly compute the mapping from its input to its reject
    state on the basis that H correctly predicts that D correctly simulated
    by H would never halt (reach its own "return" statement and terminate
    normally).

    Everyone attempting to refute the above verified fact either
    uses the strawman deception to change the subject away from
    [D correctly simulated by H]
    or flat out lies about the behavior of
    [D correctly simulated by H]



    *Complete halt deciding system* (Visual Studio Project)
    https://liarparadox.org/2023_02_07.zip

    *Simulating Halt Deciders Defeat the Halting Theorem*
    https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem


    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.

    And it is universally understood (by the definition of a UTM) that D
    correctly simulated by H necessarily demonstrates the actual behavior
    specified by this input.


    Therefore A halt decider H can be based on a UTM such that H continues
    to simulate its input until H correctly determines that D correctly
    simulated by H would never halt.

    Because H is based on a UTM we know that the behavior that H is
    evaluating is the behavior specified by its input.


    H acts like a UTM and simulates its input until H correctly determines
    that D correctly simulated by H would never reach its own "return"
    statement and terminate normally.

    --
    Copyright 2023 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 Fri Feb 17 11:07:03 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/17/23 10:04 AM, olcott wrote:
    On 2/17/2023 8:24 AM, olcott wrote:
    On 2/16/2023 8:03 PM, olcott wrote:
    On 2/16/2023 2:24 PM, olcott wrote:
    int D(int (*x)())
    {
       int Halt_Status = H(x, x);
       if (Halt_Status)
         HERE: goto HERE;
       return Halt_Status;
    }

    int main()
    {
       Output("Input_Halts = ", H(D,D));
       Output("Input_Halts = ", D(D));
    }

    *Here is my current irrefutable reasoning*
    H(D,D) does correctly compute the mapping from its input to its reject >>>> state on the basis that H correctly predicts that D correctly simulated >>>> by H would never halt (reach its own "return" statement and terminate
    normally).

    Everyone attempting to refute the above verified fact either
    uses the strawman deception to change the subject away from
    [D correctly simulated by H]
    or flat out lies about the behavior of
    [D correctly simulated by H]



    *Complete halt deciding system* (Visual Studio Project)
    https://liarparadox.org/2023_02_07.zip

    *Simulating Halt Deciders Defeat the Halting Theorem*
    https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem


    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.

    And it is universally understood (by the definition of a UTM) that D
    correctly simulated by H necessarily demonstrates the actual behavior
    specified by this input.


    Therefore A halt decider H can be based on a UTM such that H continues
    to simulate its input until H correctly determines that D correctly
    simulated by H would never halt.

    Because H is based on a UTM we know that the behavior that H is
    evaluating is the behavior specified by its input.


    H acts like a UTM and simulates its input until H correctly determines
    that D correctly simulated by H would never reach its own "return"
    statement and terminate normally.


    No, if can't be "like a UTM until ..." that just isn't like a UTM.

    That is like saying you are just like an immortal being until you die,
    thus you can call yourself immortal.

    You don't understand what being something means.

    Maybe that is why you have at various times claimed to be "like God"
    because you don't understand what that means.

    You are not immortal, but maybe immoral due to your past history that
    has been revealed.

    H is NOT a Halt Decider, because 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.

    Since D(D) has been shown to Halt, and you have even admittted that,
    H(D,D) can NOT be a correct halt decider and say non-halting.

    Either H isn't correct, or isn't a Halt Decider.

    You claim that it is a correct halt decider is just proven to be a LIE
    and shows that you are totally ignorant of the topic you are talking about.

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