• Re: Concise refutation of halting problem proofs V17 [ pathological sel

    From olcott@21:1/5 to All on Thu Nov 18 14:17:16 2021
    XPost: comp.theory, sci.logic, sci.math

    On 11/18/2021 1:01 PM, André G. Isaak wrote:
    On 2021-11-18 10:23, olcott wrote:
    On 11/18/2021 10:55 AM, Ben Bacarisse wrote:
    Mr Flibble <flibble@reddwarf.jmc> writes:

    On Thu, 18 Nov 2021 06:29:26 -0500
    Richard Damon <Richard@Damon-Family.org> wrote:

    H(P,P) is supposed to say what P(P) will do.

    No,

    So what arguments does one pass to H to find out is P(P) halts?

    This is the same code that you modified.

    ???

    How is that a response?


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

    int H(ptr x, ptr y)
    {
    x(y); // direct execution of P(P)
    return 1;
    }

    // Minimal essence of Linz(1990) Ĥ
    // and Strachey(1965) P
    int P(ptr x)
    {
    H(x, x);
    return 1; // Give P a last instruction at the "c" level
    }

    int main(void)
    {
    H(P, P);
    }

    We can see the arguments passed to H prove that P never reaches its last instruction.

    We have a computation, P(P), which you acknowledge halts.


    We have a precisely defined set of sequences of x86 instructions as combinations of H/P such that the relationship between H and P is always pathological self-reference:

    For every possible H of H(P,P) invoked from main() where P(P) calls this
    same H(P,P) and H simulates or executes its input and aborts or does not
    abort its input P never reaches its last instruction.

    P(P) is not in this set thus a strawman error when used as a rebuttal to
    the behavior of elements in the defined set.

    We also have H which you claim to be a halt decider.


    I haven't gotten to that point yet, first I prove that the "impossible"
    input is decidable, then after this is accepted then I show the trivial
    step required for H to make this correct halt status decision.

    So let's say someone doesn't know whether P(P) halts. But they have your
    halt decider H, and a halt decider should be able to answer this
    question for them. That's what halt deciders are for, after all.


    A simple bench check of the 21 lines of C code conclusively proves that
    P never reaches its final instruction.

    A more complex analysis proves that no element of the infinite
    pathological self-reference set of H/P does P ever reach its final
    instruction.

    So what input do they give to H so that H will correctly tell them that
    P(P) halts?

    André



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