• =?UTF-8?Q?Re=3a_Reviewers_quit_reviewing_my_work_because_it_is_now_?= =

    From olcott@21:1/5 to Richard Damon on Sat Jun 18 08:19:50 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/18/2022 7:52 AM, Richard Damon wrote:
    On 6/18/22 8:32 AM, olcott wrote:
    On 6/18/2022 7:24 AM, wij wrote:
    On Saturday, 18 June 2022 at 20:07:56 UTC+8, olcott wrote:
    On 6/18/2022 4:09 AM, Malcolm McLean wrote:
    On Friday, 17 June 2022 at 12:29:37 UTC+1, olcott wrote:
    When a simulating halt decider rejects all inputs as non-halting
    whenever it correctly detects that its correct and complete
    simulation
    of its input would never reach the final state of this input then all >>>>>> [these] inputs (including pathological inputs) are decided correctly. >>>>>>
    *computation that halts* … the Turing machine will halt whenever it >>>>>> enters a final state. (Linz:1990:234)

    Linz, Peter 1990. An Introduction to Formal Languages and Automata. >>>>>> Lexington/Toronto: D. C. Heath and Company. (317-320)

    #include <stdint.h>
    typedef void (*ptr)();

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

    int main()
    {
    Output("Input_Halts = ", H(P, 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]

    (1) It is an easily verified fact that when we assume that H is
    only an
    x86 emulator that the correctly emulated P never reaches its "ret" >>>>>> instruction it remains stuck in repeated cycles of emulation.

    Yes.

    (2) It is an easily verified fact that if H has been adapted to
    correctly detect (in a finite number of steps) that the correct and >>>>>> complete x86 emulation of its input would never each its "ret"
    instruction that H could abort its emulation and return 0 to
    report this.

    Yes.

    (3) When the halt status criteria is defined as correctly determining >>>>>> whether or not an x86 emulated input would ever reach its "ret"
    instruction then it becomes an easily verified fact H(P,P) could
    correctly reject its input as non-halting.

    No. Because by changing H from emulator to halt decider, you have
    changed
    P.
    When H(P,P) correctly determines that P would never reach its "ret"
    instruction (AKA final state) this makes H a halt decider for this
    input
    by definition:

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

    Linz, Peter 1990. An Introduction to Formal Languages and Automata.
    Lexington/Toronto: D. C. Heath and Company. (317-320)
    --
    Copyright 2022 Pete Olcott

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

    GUR is repeatedly proved:
      olcott can never provide a real halting decider except a verbal one.
    Thanks olcott.

    This one proves that H(P,P) does correctly determine that H(P,P)==0 is
    correct:

    H(P,P)==0 as a pure function of its inputs is fully operational V2
    On 6/17/2022 9:31 PM, olcott wrote:


    Except it isn't since H(P,P) returns 0, saying that P(P) is non-halting,
    when P(P) will halt when H(P,P) returns 0.

    If H(P,P) isn't asking about P(P), then you don't have the right
    function P, as the Linz definition of P is that it will ask about that.

    (X) H(P,P) correctly determines (in a finite number of steps) that the
    correct and complete x86 emulation of its input would never reach the
    "ret" instruction (AKA final state) of this input.

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

    (Z) H(P,P) has correctly determined that its input is non-halting.

    When we know that X & Y proves Z and we know X & Y then Z is proved.
    Failing to agree with this last line is sufficient evidence of dishonesty.



    Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)


    --
    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 Jun 18 09:52:39 2022
    XPost: comp.theory, sci.logic, sci.math

    On 6/18/22 9:19 AM, olcott wrote:
    On 6/18/2022 7:52 AM, Richard Damon wrote:
    On 6/18/22 8:32 AM, olcott wrote:
    On 6/18/2022 7:24 AM, wij wrote:
    On Saturday, 18 June 2022 at 20:07:56 UTC+8, olcott wrote:
    On 6/18/2022 4:09 AM, Malcolm McLean wrote:
    On Friday, 17 June 2022 at 12:29:37 UTC+1, olcott wrote:
    When a simulating halt decider rejects all inputs as non-halting >>>>>>> whenever it correctly detects that its correct and complete
    simulation
    of its input would never reach the final state of this input then >>>>>>> all
    [these] inputs (including pathological inputs) are decided
    correctly.

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

    Linz, Peter 1990. An Introduction to Formal Languages and Automata. >>>>>>> Lexington/Toronto: D. C. Heath and Company. (317-320)

    #include <stdint.h>
    typedef void (*ptr)();

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

    int main()
    {
    Output("Input_Halts = ", H(P, 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]

    (1) It is an easily verified fact that when we assume that H is
    only an
    x86 emulator that the correctly emulated P never reaches its "ret" >>>>>>> instruction it remains stuck in repeated cycles of emulation.

    Yes.

    (2) It is an easily verified fact that if H has been adapted to
    correctly detect (in a finite number of steps) that the correct and >>>>>>> complete x86 emulation of its input would never each its "ret"
    instruction that H could abort its emulation and return 0 to
    report this.

    Yes.

    (3) When the halt status criteria is defined as correctly
    determining
    whether or not an x86 emulated input would ever reach its "ret"
    instruction then it becomes an easily verified fact H(P,P) could >>>>>>> correctly reject its input as non-halting.

    No. Because by changing H from emulator to halt decider, you have
    changed
    P.
    When H(P,P) correctly determines that P would never reach its "ret"
    instruction (AKA final state) this makes H a halt decider for this
    input
    by definition:

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

    Linz, Peter 1990. An Introduction to Formal Languages and Automata.
    Lexington/Toronto: D. C. Heath and Company. (317-320)
    --
    Copyright 2022 Pete Olcott

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

    GUR is repeatedly proved:
      olcott can never provide a real halting decider except a verbal one. >>>> Thanks olcott.

    This one proves that H(P,P) does correctly determine that H(P,P)==0
    is correct:

    H(P,P)==0 as a pure function of its inputs is fully operational V2
    On 6/17/2022 9:31 PM, olcott wrote:


    Except it isn't since H(P,P) returns 0, saying that P(P) is
    non-halting, when P(P) will halt when H(P,P) returns 0.

    If H(P,P) isn't asking about P(P), then you don't have the right
    function P, as the Linz definition of P is that it will ask about that.

    (X) H(P,P) correctly determines (in a finite number of steps) that the correct and complete x86 emulation of its input would never reach the
    "ret" instruction (AKA final state) of this input.

    FALSE. Only proven for all H(P,P) that actually DO a complete x86
    emulation of its input, and those can't do it in a finite number of
    steps. The H(P,P) that you have proven it for NEVER return 0 from
    H(P,P). The H you are now talking about DOES return 0, and thus DOES
    abort its simulation and thus DOES NOT actually do a complete x86
    emulation of its input, so not applicable here.

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

    True/


    (Z) H(P,P) has correctly determined that its input is non-halting.

    Nope, it has correctly determined that A DIFFERENT P/H combination is non-halting, not itself.


    When we know that X & Y proves Z and we know X & Y then Z is proved.
    Failing to agree with this last line is sufficient evidence of dishonesty.


    So, since you never proved X for the H that you are talking about, you
    haven't proved your point.

    FAIL.



    Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (317-320)



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