• Re: Ben's agreement that D must be aborted by H --- Better words now.

    From Richard Damon@21:1/5 to olcott on Mon Jul 22 20:01:09 2024
    XPost: comp.theory

    On 7/22/24 3:50 PM, olcott wrote:
    On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
    Python <python@invalid.org> writes:

    Olcott (annotated):

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

       [comment: as D halts, the simulation is faulty, Pr. Sipser has been >>>     fooled by Olcott shell game confusion "pretending to simulate" and >>>     "correctly simulate"]

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

    I don't think that is the shell game.  PO really /has/ an H (it's
    trivial to do for this one case) that correctly determines that P(P)
    *would* never stop running *unless* aborted.  He knows and accepts that
    P(P) actually does stop.  The wrong answer is justified by what would
    happen if H (and hence a different P) where not what they actually are.

    (I've gone back to his previous names what P is Linz's H^.)

    In other words: "if the simulation were right the answer would be
    right".

    I don't think that's the right paraphrase.  He is saying if P were
    different (built from a non-aborting H) H's answer would be the right
    one.

    But the simulation is not right. D actually halts.

    But H determines (correctly) that D would not halt if it were not
    halted.  That much is a truism.

    It is also a truism that any input that must be aborted to
    prevent the non-termination of the simulating termination
    analyzer does specify non-terminating behavior or it would
    never need to aborted.

    Right, and since if you give AND of the DDD that call an HHH that aborts
    and returns (where the input still calls that HHH as required) to a
    simulator the just runs to completion (put into memory in unused memory
    space) it WILL simulate to the completion state, shows that by even your definition, those DDD are HALTING.

    Your problem is you claim that NO decider can simulate it, but you only
    gave that input to ONE simulator, and one that doesn't simulate it far
    enough.

    You just don't understand that the input MUST include ALL the code that
    the program will execute, or you just can't simulate that input more
    that 4 steps, so your logic is just broken,


    We compute the mapping from the finite string machine code
    of D to the behavior that this finite string of x86 machine
    code specifies on the basis of D correctly emulated by H
    according to the semantics of this x86 machine code.

    And if you give that input D, that calls the H that answers by aborting
    its simulation (and thus NOT doing a correct simulation by the
    definitions that allow simulation to reveal full behavior) and give that
    to a DIFFERENT H, at an unused memory location, it WILL simulate the
    input to the end,


    What's wrong is to pronounce that
    answer as being correct for the D that does, in fact, stop.

    And Peter Olcott is a [*beep*]

    It's certainly dishonest to claim support from an expert who clearly
    does not agree with the conclusions.  Pestering, and then tricking,
    someone into agreeing to some vague hypothetical is not how academic
    research is done.  Had PO come clean and ended his magic paragraph with
    "and therefore 'does not 'halt' is the correct answer even though D
    halts" he would have got a more useful reply.


    You are conflating two different process instances that
    have different process states. The D correctly simulated
    by H is an entirely different process than D(D) directly
    executed in main().

    But the MUST have the same behavior, and the do as described above.

    All you are doing is showing your utter ignorance of how programs work.


    D correctly emulated by H specifies recursive emulation
    that must be aborted. D(D) directly executed in main()
    does not specify recursive emulation that must be aborted.

    But you H don't correctly emulate their input if the abort, and thus
    don't give the full detail of the behavior of the full input.


    The D correctly simulated by H must be aborted in the same
    way that when you are hungry you must eat.

    No, I guess you never heard of fasting? Some people will go "hungry" for
    quite a while. And the metaphore is incorrect as "Needs to be aborts" is
    a constant property of a given program, while "hungery" is a transient
    property of a being.


    The D(D) directly executed in main() need not be aborted
    in the same way that you are no longer hungry after you
    have eaten.

    Bad analogy, Just shows your stupdity.


    Let's keep in mind this is exactly what he's saying:

       "Yes [H(P,P) == false] is the correct answer even though P(P) halts." >>
    Why?  Because:

       "we can prove that Halts() did make the correct halting decision when >>    we comment out the part of Halts() that makes this decision and
       H_Hat() remains in infinite recursion"



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