1. Forum
  2. Usenet
  3. COMP.AI.PHILOSOPHY

  • Re: Competent software engineers will agree that H(P,P)==0 is correct

    From olcott@21:1/5 to wij on Mon Jun 6 10:55:00 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/6/2022 10:44 AM, wij wrote:
    On Monday, 6 June 2022 at 23:24:09 UTC+8, olcott wrote:
    Software engineers competent in C and the x86 language will verify that
    when H(P,P) correctly emulates its input with an x86 emulator that this
    emulation would never stop running. This provides the basis for H(P,P)
    to correctly reject its input as non-halting.

    For any program H that might determine if programs halt, a
    "pathological"
    program P, called with some input, can pass its own source and its
    input to
    H and then specifically do the opposite of what H predicts P will
    do. No H
    can exist that handles this case.
    https://en.wikipedia.org/wiki/Halting_problem

    H determines the halt status of its input by watching the behavior of
    this input when it is correctly simulated by H using an x86 emulator.
    When H correctly matches an infinite behavior pattern it aborts the
    emulation of this input and returns 0.

    #include <stdint.h>
    #define u32 uint32_t

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

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

    _P()
    [00001352](01) 55 push ebp
    [00001353](02) 8bec mov ebp,esp
    [00001355](03) 8b4508 mov eax,[ebp+08]
    [00001358](01) 50 push eax // push P
    [00001359](03) 8b4d08 mov ecx,[ebp+08]
    [0000135c](01) 51 push ecx // push P
    [0000135d](05) e840feffff call 000011a2 // call H
    [00001362](03) 83c408 add esp,+08
    [00001365](02) 85c0 test eax,eax
    [00001367](02) 7402 jz 0000136b
    [00001369](02) ebfe jmp 00001369
    [0000136b](01) 5d pop ebp
    [0000136c](01) c3 ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its input
    that it must emulate the first seven instructions of P. Because the
    seventh instruction repeats this process we can know with complete
    certainty that the emulated P never reaches its final “ret” instruction, >> thus never halts.

    --
    Copyright 2022 Pete Olcott

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

    Students of average level understand Halting decider cannot exist, as olcott has demonstrated for years (no 'correct' H exists).

    If H does not exist, what dose "H(P,P)==0" mean?

    Not only does H exist, it is fully operational software thus your
    assumption is proven false by the verified facts.

    when H(P,P) correctly emulates its input with an x86 emulator this
    emulation would never stop running. This provides the basis for H(P,P)
    to correctly reject its input as non-halting.



    --
    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 wij on Mon Jun 6 11:35:26 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/6/2022 11:15 AM, wij wrote:
    On Monday, 6 June 2022 at 23:55:09 UTC+8, olcott wrote:
    On 6/6/2022 10:44 AM, wij wrote:
    On Monday, 6 June 2022 at 23:24:09 UTC+8, olcott wrote:
    Software engineers competent in C and the x86 language will verify that >>>> when H(P,P) correctly emulates its input with an x86 emulator that this >>>> emulation would never stop running. This provides the basis for H(P,P) >>>> to correctly reject its input as non-halting.

    For any program H that might determine if programs halt, a
    "pathological"
    program P, called with some input, can pass its own source and its
    input to
    H and then specifically do the opposite of what H predicts P will
    do. No H
    can exist that handles this case.
    https://en.wikipedia.org/wiki/Halting_problem

    H determines the halt status of its input by watching the behavior of
    this input when it is correctly simulated by H using an x86 emulator.
    When H correctly matches an infinite behavior pattern it aborts the
    emulation of this input and returns 0.

    #include <stdint.h>
    #define u32 uint32_t

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

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

    _P()
    [00001352](01) 55 push ebp
    [00001353](02) 8bec mov ebp,esp
    [00001355](03) 8b4508 mov eax,[ebp+08]
    [00001358](01) 50 push eax // push P
    [00001359](03) 8b4d08 mov ecx,[ebp+08]
    [0000135c](01) 51 push ecx // push P
    [0000135d](05) e840feffff call 000011a2 // call H
    [00001362](03) 83c408 add esp,+08
    [00001365](02) 85c0 test eax,eax
    [00001367](02) 7402 jz 0000136b
    [00001369](02) ebfe jmp 00001369
    [0000136b](01) 5d pop ebp
    [0000136c](01) c3 ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its input >>>> that it must emulate the first seven instructions of P. Because the
    seventh instruction repeats this process we can know with complete
    certainty that the emulated P never reaches its final “ret” instruction,
    thus never halts.

    --
    Copyright 2022 Pete Olcott

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

    Students of average level understand Halting decider cannot exist, as olcott
    has demonstrated for years (no 'correct' H exists).

    If H does not exist, what dose "H(P,P)==0" mean?
    Not only does H exist, it is fully operational software thus your
    assumption is proven false by the verified facts.

    The verified fact (Everybody can see) is that NO ONE has ever seen your H. ()

    Which makes no difference at all when we simply stipulate a hypothetical
    H that performs an x86 emulation of its input.

    The verified fact (Everybody can see) is that the (descriptive) POOH is not a Halting decider.

    In other words you are asserting (against the easily verified facts)
    that a correct and complete x86 emulation of the input to H(P,P) by H
    would reach the "ret" instruction of P.

    If you are asserting this that would prove that you are woefully lacking
    in the required software engineering skills in C, the x86 language and
    x86 emulation.

    The verified fact (Everybody can see) is that your claims (lies actually) changes all the time.


    I have been constantly improving the clarity of my writing.

    when H(P,P) correctly emulates its input with an x86 emulator this
    emulation would never stop running. This provides the basis for H(P,P)
    to correctly reject its input as non-halting.

    IIRC, this is another version of 'claim' of your H. Still no H?
    What do you expect reviewers to say about H while H is not shown?


    --
    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 wij on Mon Jun 6 13:11:28 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/6/2022 12:05 PM, wij wrote:
    On Tuesday, 7 June 2022 at 00:35:35 UTC+8, olcott wrote:
    On 6/6/2022 11:15 AM, wij wrote:
    On Monday, 6 June 2022 at 23:55:09 UTC+8, olcott wrote:
    On 6/6/2022 10:44 AM, wij wrote:
    On Monday, 6 June 2022 at 23:24:09 UTC+8, olcott wrote:
    Software engineers competent in C and the x86 language will verify that >>>>>> when H(P,P) correctly emulates its input with an x86 emulator that this >>>>>> emulation would never stop running. This provides the basis for H(P,P) >>>>>> to correctly reject its input as non-halting.

    For any program H that might determine if programs halt, a
    "pathological"
    program P, called with some input, can pass its own source and its >>>>>> input to
    H and then specifically do the opposite of what H predicts P will
    do. No H
    can exist that handles this case.
    https://en.wikipedia.org/wiki/Halting_problem

    H determines the halt status of its input by watching the behavior of >>>>>> this input when it is correctly simulated by H using an x86 emulator. >>>>>> When H correctly matches an infinite behavior pattern it aborts the >>>>>> emulation of this input and returns 0.

    #include <stdint.h>
    #define u32 uint32_t

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

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

    _P()
    [00001352](01) 55 push ebp
    [00001353](02) 8bec mov ebp,esp
    [00001355](03) 8b4508 mov eax,[ebp+08]
    [00001358](01) 50 push eax // push P
    [00001359](03) 8b4d08 mov ecx,[ebp+08]
    [0000135c](01) 51 push ecx // push P
    [0000135d](05) e840feffff call 000011a2 // call H
    [00001362](03) 83c408 add esp,+08
    [00001365](02) 85c0 test eax,eax
    [00001367](02) 7402 jz 0000136b
    [00001369](02) ebfe jmp 00001369
    [0000136b](01) 5d pop ebp
    [0000136c](01) c3 ret
    Size in bytes:(0027) [0000136c]

    It is completely obvious that when H(P,P) correctly emulates its input >>>>>> that it must emulate the first seven instructions of P. Because the >>>>>> seventh instruction repeats this process we can know with complete >>>>>> certainty that the emulated P never reaches its final “ret” instruction,
    thus never halts.

    --
    Copyright 2022 Pete Olcott

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

    Students of average level understand Halting decider cannot exist, as olcott
    has demonstrated for years (no 'correct' H exists).

    If H does not exist, what dose "H(P,P)==0" mean?
    Not only does H exist, it is fully operational software thus your
    assumption is proven false by the verified facts.

    The verified fact (Everybody can see) is that NO ONE has ever seen your H. ()
    Which makes no difference at all when we simply stipulate a hypothetical
    H that performs an x86 emulation of its input.

    A proof that "H(P,P)==0 is correct" without showing what the H is is a garbage proof,
    unconditionally.


    Proving that H would be correct if H(P,P) rejected its input as
    non-halting is ridiculously simple and totally obviously correct.

    This is what H(P,P)==0 is correct means.

    --
    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)