• Every E correctly simulated by any HH cannot possibly halt V2

    From olcott@21:1/5 to All on Sat Feb 11 21:21:04 2023
    XPost: comp.theory, sci.logic

    Every E correctly simulated by any HH cannot possibly halt
    (AKA reach its own return instruction and terminate normally)

    void E(int (*x)())
    {
    HH(x, x);
    return;
    }

    int main()
    {
    HH(E,E);
    }

    Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
    instruction in any finite number of steps of correct simulation.

    HH only needs to simulate E until HH correctly detects that E has a
    repeating state such that E correctly simulated by HH cannot possibly
    reach its own final state an terminate normally in any finite number of
    steps. *Fully operational software linked below proves this*

    *Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

    *Complete halt deciding system* (Visual Studio Project)
    (a) x86utm operating system
    (b) x86 emulator adapted from libx86emu to compile under Windows
    (c) Several halt deciders and their sample inputs contained within Halt7.c

    https://liarparadox.org/2023_02_07.zip


    --
    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 Sun Feb 12 06:57:31 2023
    XPost: comp.theory, sci.logic

    Your repeaing this claim withput answering the objectsions only proves
    you have no basis for your claims.

    You are admitting you have lost.


    On 2/11/23 10:21 PM, olcott wrote:
    Every E correctly simulated by any HH cannot possibly halt
    (AKA reach its own return instruction and terminate normally)

    But every E that is decided by the HH it is built on will Halt.

    Thus, no HH that decides on the D built on itself actually correctly
    simulates its input, but aborts it without proof of being non-halting.

    void E(int (*x)())
    {
      HH(x, x);
      return;
    }

    int main()
    {
      HH(E,E);
    }

    Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
    instruction in any finite number of steps of correct simulation.

    Right, because *IF* HH does a correct simulation, it is impossible for
    it to reach a valid conclusion


    HH only needs to simulate E until HH correctly detects that E has a
    repeating state such that E correctly simulated by HH cannot possibly
    reach its own final state an terminate normally in any finite number of steps. *Fully operational software linked below proves this*

    The Fullu operational software linked below proves that it does not get
    the right answer because the decider doesn't actually PROVE that its
    input is non-halting, but uses a FALSE premise to make its decision.

    The problem is your Decider assumes that the copy of the decider called
    will fulfil the requriements, when it doesn't.

    It is just another example of the fact that you don't understand how
    logic works and you seem to fall into every known logical fallacy.

    This is likely because you have admitted that you live in a world of
    enforced ignorance because you are afraid of being contaminated by the
    Truth.


    *Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

    *Complete halt deciding system* (Visual Studio Project)
    (a) x86utm operating system
    (b) x86 emulator adapted from libx86emu to compile under Windows
    (c) Several halt deciders and their sample inputs contained within Halt7.c

    https://liarparadox.org/2023_02_07.zip



    SOrry, you are just proving you are a totoal idiot.

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

    On 2/11/2023 9:21 PM, olcott wrote:
    Every E correctly simulated by any HH cannot possibly halt
    (AKA reach its own return instruction and terminate normally)

    void E(int (*x)())
    {
      HH(x, x);
      return;
    }

    int main()
    {
      HH(E,E);
    }

    Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
    instruction in any finite number of steps of correct simulation.

    HH only needs to simulate E until HH correctly detects that E has a
    repeating state such that E correctly simulated by HH cannot possibly
    reach its own final state an terminate normally in any finite number of steps. *Fully operational software linked below proves this*

    *Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

    *Complete halt deciding system* (Visual Studio Project)
    (a) x86utm operating system
    (b) x86 emulator adapted from libx86emu to compile under Windows
    (c) Several halt deciders and their sample inputs contained within Halt7.c

    https://liarparadox.org/2023_02_07.zip



    Because it is an easily verified fact that
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH
    cannot possibly halt
    (reach its own "return" instruction and terminate normally)

    It is necessarily correct for HH to abort its simulation of E and reject
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH

    as non-halting as soon as it detects the repeating state in
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH

    *straw man*
    An intentionally misrepresented proposition that is set up because it is
    easier to defeat than an opponent's real argument. https://www.lexico.com/en/definition/straw_man

    --
    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 olcott@21:1/5 to olcott on Sun Feb 12 10:16:27 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/11/2023 9:21 PM, olcott wrote:
    Every E correctly simulated by any HH cannot possibly halt
    (AKA reach its own return instruction and terminate normally)

    void E(int (*x)())
    {
      HH(x, x);
      return;
    }

    int main()
    {
      HH(E,E);
    }

    Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
    instruction in any finite number of steps of correct simulation.

    HH only needs to simulate E until HH correctly detects that E has a
    repeating state such that E correctly simulated by HH cannot possibly
    reach its own final state an terminate normally in any finite number of steps. *Fully operational software linked below proves this*

    *Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

    *Complete halt deciding system* (Visual Studio Project)
    (a) x86utm operating system
    (b) x86 emulator adapted from libx86emu to compile under Windows
    (c) Several halt deciders and their sample inputs contained within Halt7.c

    https://liarparadox.org/2023_02_07.zip



    *Because it is an easily verified fact that*
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH
    cannot possibly halt
    (reach its own "return" instruction and terminate normally)

    *HH is necessarily correct to abort its simulation of E and reject*
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH

    *as non-halting as soon as it detects the repeating state in*
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH

    *straw man*
    An intentionally misrepresented proposition that is set up because it is
    easier to defeat than an opponent's real argument. https://www.lexico.com/en/definition/straw_man



    --
    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 Sun Feb 12 15:28:06 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/12/23 11:10 AM, olcott wrote:
    On 2/11/2023 9:21 PM, olcott wrote:
    Every E correctly simulated by any HH cannot possibly halt
    (AKA reach its own return instruction and terminate normally)

    void E(int (*x)())
    {
       HH(x, x);
       return;
    }

    int main()
    {
       HH(E,E);
    }

    Two people with masters degrees in computer science have agreed that E
    correctly simulated by HH cannot possibly reach its own "return"
    instruction in any finite number of steps of correct simulation.

    HH only needs to simulate E until HH correctly detects that E has a
    repeating state such that E correctly simulated by HH cannot possibly
    reach its own final state an terminate normally in any finite number of
    steps. *Fully operational software linked below proves this*

    *Simulating Halt Decider Applied to the Halting Theorem*
    https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

    *Complete halt deciding system* (Visual Studio Project)
    (a) x86utm operating system
    (b) x86 emulator adapted from libx86emu to compile under Windows
    (c) Several halt deciders and their sample inputs contained within
    Halt7.c

    https://liarparadox.org/2023_02_07.zip



    Because it is an easily verified fact that
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH
    cannot possibly halt
    (reach its own "return" instruction and terminate normally)

    Just as it is easily verified that IF HH correctly simulated E, it never
    aborts and returns an answer, so fails to be a decider.



    It is necessarily correct for HH to abort its simulation of E and reject
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH


    Nope, that is saying it is correct to give an answer based on false assumptions.

    HH either DOES correctly simulate E, and thus never anwwers, or HH
    DOESN'T correctly simulate E and usies INVALID logic to claim its answer
    is incorrecgt.



    as non-halting as soon as it detects the repeating state in
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH

    And there is no EXACTLY repeating state in E correctly simulated by HH,
    as what HH sees as it simulates is:

    it simulating the instructionss of E to the call to HH

    then it simulating the code of HH simulating the instuctions of E utill
    that reaches a call to HH

    then it simulationg the code of HH simulating the code of HH simmulating
    the instructions of E untill....

    You never reach the EXACT same state.


    *straw man*
    An intentionally misrepresented proposition that is set up because it is easier to defeat than an opponent's real argument. https://www.lexico.com/en/definition/straw_man


    Right, just what you are providing.

    Remember, the ACTUAL question given to a Halting Decider is what is the behavior of the machine its input describes, when that machine would be actually run.

    By the definiton of a UTM, that can be replaced by asking the Halting
    Decider what is the behavior of the simulation done by a UTM simulating
    the input to this halt decider.

    Changing that simulation from a UTH to the Decider is just preforming a
    Straw Man.

    Your continued use of this just shows you are either totally ignorant of
    the actual rules of logic or that you are just a pathological liar.

    You will likely not actually respond to this, but just repeat your
    claim, PROVING you don't actually HAVE a valid response to it.


    Your REPUTATION is MUD, and for as long as you are remembered it will be
    as the idiot that you have proven yourself to be.

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

    On 2/12/2023 10:16 AM, olcott wrote:
    On 2/11/2023 9:21 PM, olcott wrote:
    Every E correctly simulated by any HH cannot possibly halt
    (AKA reach its own return instruction and terminate normally)

    void E(int (*x)())
    {
       HH(x, x);
       return;
    }

    int main()
    {
       HH(E,E);
    }

    Two people with masters degrees in computer science have agreed that E
    correctly simulated by HH cannot possibly reach its own "return"
    instruction in any finite number of steps of correct simulation.

    HH only needs to simulate E until HH correctly detects that E has a
    repeating state such that E correctly simulated by HH cannot possibly
    reach its own final state an terminate normally in any finite number of
    steps. *Fully operational software linked below proves this*

    *Simulating Halt Decider Applied to the Halting Theorem*
    https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

    *Complete halt deciding system* (Visual Studio Project)
    (a) x86utm operating system
    (b) x86 emulator adapted from libx86emu to compile under Windows
    (c) Several halt deciders and their sample inputs contained within
    Halt7.c

    https://liarparadox.org/2023_02_07.zip



    *Because it is an easily verified fact that*
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH
    cannot possibly halt
    (reach its own "return" instruction and terminate normally)

    *HH is necessarily correct to abort its simulation of E and reject*
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH

    *as non-halting as soon as it detects the repeating state in*
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH


    The repeating state that we and HH can both see is that
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH
    would continue to call HH(E,E) in recursive simulation
    making it impossible for
    E correctly simulated by H
    E correctly simulated by H
    E correctly simulated by H
    to reach its own "return" instruction and terminate normally (AKA halt).

    *straw man*
    An intentionally misrepresented proposition that is set up because it is easier to defeat than an opponent's real argument. https://www.lexico.com/en/definition/straw_man



    --
    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 Mon Feb 13 18:56:08 2023
    XPost: comp.theory, sci.logic, comp.software-eng

    On 2/13/23 11:17 AM, olcott wrote:
    On 2/12/2023 10:16 AM, olcott wrote:
    On 2/11/2023 9:21 PM, olcott wrote:
    Every E correctly simulated by any HH cannot possibly halt
    (AKA reach its own return instruction and terminate normally)

    void E(int (*x)())
    {
       HH(x, x);
       return;
    }

    int main()
    {
       HH(E,E);
    }

    Two people with masters degrees in computer science have agreed that E
    correctly simulated by HH cannot possibly reach its own "return"
    instruction in any finite number of steps of correct simulation.

    HH only needs to simulate E until HH correctly detects that E has a
    repeating state such that E correctly simulated by HH cannot possibly
    reach its own final state an terminate normally in any finite number of
    steps. *Fully operational software linked below proves this*

    *Simulating Halt Decider Applied to the Halting Theorem*
    https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

    *Complete halt deciding system* (Visual Studio Project)
    (a) x86utm operating system
    (b) x86 emulator adapted from libx86emu to compile under Windows
    (c) Several halt deciders and their sample inputs contained within
    Halt7.c

    https://liarparadox.org/2023_02_07.zip



    *Because it is an easily verified fact that*
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH
    cannot possibly halt
    (reach its own "return" instruction and terminate normally)

    *HH is necessarily correct to abort its simulation of E and reject*
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH

    *as non-halting as soon as it detects the repeating state in*
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH


    The repeating state that we and HH can both see is that
    E correctly simulated by HH
    E correctly simulated by HH
    E correctly simulated by HH
    would continue to call HH(E,E) in recursive simulation
    making it impossible for
    E correctly simulated by H
    E correctly simulated by H
    E correctly simulated by H
    to reach its own "return" instruction and terminate normally (AKA halt).

    *straw man*
    An intentionally misrepresented proposition that is set up because it is
    easier to defeat than an opponent's real argument.
    https://www.lexico.com/en/definition/straw_man





    Nope.

    I replied to you ranting, you have ignored my statements because you
    have NO answer to it, so you are admitting you are a failure and are
    using flawed logic.

    YOU ARE ADMITTING FAILURE BY NOT RESPONDING TO THE REBUTAL.

    You are just proving that you are a ignorant pathological lying idiot.

    Your arguement is base on simple lies that are based on assuming the
    impossible happens.

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