• Re: Reply to Ben's long standing objection --- I finally have the words

    From Richard Damon@21:1/5 to olcott on Fri May 17 21:07:32 2024
    XPost: comp.theory, sci.logic

    On 5/17/24 2:46 PM, olcott wrote:
    On 5/17/2024 7:50 AM, Ben Bacarisse wrote:
    joes <noreply@example.com> writes:

    Am Thu, 16 May 2024 22:29:14 -0400 schrieb Richard Damon:

    Yep, perhaps some day soon we will be rid of your lies.
    That’s low.
    Your continuous cries of „liar” aren’t any better than Peter’s spam.

    When I did engage with him it was to try to pin down what he was really
    saying and, after years of back-and-forth, he made two unequivocal
    statement that, to my mind, render all subsequent discussion pointless.
    First, when asked

         "Here's the key question: do you still assert that H(P,P) ==
    false is
         the 'correct' answer even though P(P) halts?"

    He replied:

        "Yes that is the correct answer even though P(P) halts."

    Computable functions are the basic objects of study in computability
    theory. Computable functions are the formalized analogue of the
    intuitive notion of algorithms, in the sense that a function is
    computable if there exists an algorithm that can do the job of the
    function, i.e. *given an input of the function domain it can return the* *corresponding output* https://en.wikipedia.org/wiki/Computable_function

    typedef int (*ptr)();  // ptr is pointer to int function
    00 int H(ptr x, ptr x)
    01 int P(ptr x)
    02 {
    03   int Halt_Status = H(x, x);
    04   if (Halt_Status)
    05     HERE: goto HERE;
    06   return Halt_Status;
    07 }
    08
    09 int main()
    10 {
    11   P(P,P);
    12 }

    My reviewers have never been aware of the fact computable functions
    are not allowed to report on the behavior of the computation they
    themselves are contained within because deciders cannot take actual
    Turing Machines as inputs.

    This makes the behavior of the executed P(P) moot and instead H must
    report on the behavior that the input to H(P,P) specifies.

    In the above case a simulator is an x86 emulator that correctly emulates
    at least one of the x86 instructions of D in the order specified by the
    x86 instructions of D.

    This may or may not include one or more recursive simulations where H correctly simulates itself simulating D in the order specified by the
    x86 instructions of H.

    This conclusively proves that D correctly simulated by H cannot possibly reach its own line 06 and halt to everyone with sufficient knowledge
    of the semantics of the C programming knowledge.

    Which, since I posted over two weeks ago how to do it in C, means that
    you don't have the needed knowledge of the C programming language, or
    about what truth actually is. THAT is now self-evidently true.

    And the fact that you refuse to take up any of my challenges to have me
    repost the link (because you clearly prefer to just lie rather that try
    to do some research) it is clear that you are not actually certain of
    your claim, so you know you may be lying, but you do it anyway.



    *Introduction to the Theory of Computation, by Michael Sipser* https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X/

    On 10/13/2022 11:29:23 AM
    *MIT Professor Michael Sipser agreed these verbatim words are correct*
    (He has neither reviewed nor agreed to anything else in this paper)

       If simulating halt decider H correctly simulates its input D until H
       correctly determines that its simulated D would never stop running
       unless aborted then

       H can abort its simulation of D and correctly report that D specifies
       a non-halting sequence of configurations.



    Right, if H does CORRECTLY SIMULATE, or shows that the CORRECT
    SIMULATION would not halt, a correct simulation is one that doesn't abort.

    So, since UTM(D,D) Halts (when D still calls H, and not UTM, as required
    by the problem), H can not use that arguement to "correctly" determine
    that its input is not halting

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