• Re: HH(PP,PP) correctly determines that its input never halts [Why lie?

    From Richard Damon@21:1/5 to olcott on Sun Jan 29 20:04:01 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D and upon
    encountering the 8th line of D correctly determines that D would never >>>>> stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual behavior
    of that call to H by D(D) will be to abort ITS simulation (which is
    a different instance, which is also an incorrect action) and return 0. >>>>
    Thus H gets the wrong answer because it presumes that H will not get
    the wrong answer when it does.

    Until you provide the instruction in that direct execution of D(D)
    that differs from the execution of H(D,D) when called by main, you
    are just admitting that you are a Hypocritical Patholgical Lying
    Ignorant Idiot.


    In other words you are trying to get away with the counter-factual claim >>> that D correctly simulated by H would eventually reach its own final
    state and terminate normally.

    D correctly siumulated will reach its own final state. This is shown
    by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change, The definition of a Halt Decider is
    to give the answer about the behavior of the actual machine running on
    the actual input that the decider has been given. PERIOD.

    You don't get to change that. PERIOD.

    It is a CHANGE to talk about "corrct simulation", one perhaps justified
    only if you use the definition of "correct simulation" as the Simulation generated by an ACTUAL Universal Turing Machine.

    A Universal Turing Machine NEVER aborts its simulation, and the UTM
    simulation of a non-halting machine, never returns.

    To say the simulation "By H" is also equivalent and correct, means H can
    not abort its simuliation either,

    Since H does, the simulation "by H" doesn't meet the requirement for an
    correct simulation that can give a correct answer.


    D correctly simulated by H cannot possibly reach the final state of D
    and terminate normally.


    H doesn't not correctly simulate D and give a correct answer (Not per
    the required definitions). PERIOD.

    Your whole argument is based on the LIE that even though, as you have
    agreed, at least at times, that the actual direct execution of D(D) is
    to Halt, that "some how" the "Correct Answer" to the question of does it
    Halt is that it does not.

    You Hide it by trying to talk about a "Correct SImulation by H" first by appealing to the definition of a UTM, and that definiton, and then
    CHANGINING it (which is a from of LIE) to something different.

    H never does a "Correct Simulation" by any defintion that allows it to
    make claims about the behavior of the original machine, and thus you
    whole arguement is shows to be just a Hypocritcal Ignorant Pathological
    Lying attempt to prove something that is not true.


    You have wasted you LIFE chasing a LIE. You have destroyed your
    reputation and any possible reputation of the things you have supported,
    if they has any positive value in the first place.

    YOU ARE A LOSER.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Sun Jan 29 19:23:31 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/29/2023 7:04 PM, Richard Damon wrote:
    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D and upon >>>>>> encountering the 8th line of D correctly determines that D would
    never
    stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual behavior
    of that call to H by D(D) will be to abort ITS simulation (which is
    a different instance, which is also an incorrect action) and return 0. >>>>>
    Thus H gets the wrong answer because it presumes that H will not
    get the wrong answer when it does.

    Until you provide the instruction in that direct execution of D(D)
    that differs from the execution of H(D,D) when called by main, you
    are just admitting that you are a Hypocritical Patholgical Lying
    Ignorant Idiot.


    In other words you are trying to get away with the counter-factual
    claim
    that D correctly simulated by H would eventually reach its own final
    state and terminate normally.

    D correctly siumulated will reach its own final state. This is shown
    by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change,

    When D is CORRECTLY SIMULATED BY H
    D cannot possibly reach its own final state and halt.

    On the basis of the behavior that H actually sees H is necessarily
    correct. If H were to report on anything else besides that behavior that
    it actually sees H would be wrong.

    --
    Copyright 2023 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 Sun Jan 29 20:39:00 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/29/23 8:23 PM, olcott wrote:
    On 1/29/2023 7:04 PM, Richard Damon wrote:
    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D and upon >>>>>>> encountering the 8th line of D correctly determines that D would >>>>>>> never
    stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual behavior >>>>>> of that call to H by D(D) will be to abort ITS simulation (which
    is a different instance, which is also an incorrect action) and
    return 0.

    Thus H gets the wrong answer because it presumes that H will not
    get the wrong answer when it does.

    Until you provide the instruction in that direct execution of D(D) >>>>>> that differs from the execution of H(D,D) when called by main, you >>>>>> are just admitting that you are a Hypocritical Patholgical Lying
    Ignorant Idiot.


    In other words you are trying to get away with the counter-factual
    claim
    that D correctly simulated by H would eventually reach its own final >>>>> state and terminate normally.

    D correctly siumulated will reach its own final state. This is shown
    by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change,

    When D is CORRECTLY SIMULATED BY H

    Which doesn't happen if H answers, so you are just showing yourself to
    be a Pathological Liar.

    You are using invalid logic of trying to prove a statement by assuming a premiss.

    Remember the DEFINITION of "Correct Simulation" that must be used to
    make your claim.

    You ar just a Patholgocial Liar


    D cannot possibly reach its own final state and halt.

    On the basis of the behavior that H actually sees H is necessarily
    correct. If H were to report on anything else besides that behavior that
    it actually sees H would be wrong.



    Nope. H can KNOW that a call to H(D,D) will return 0. You have admitted
    that by not showing what insrruction of the actual execution of the two
    paths that differ in H.

    Thus you are admitting that you are a Hypocritical Pathological Lying
    Ignorant Idiot.

    This is proven until you can show what instruction in H, actually
    executed by the two machines differs: main -> D(D) -> H(D,D) and
    main -> H(D,D)

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Sun Jan 29 19:43:56 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/29/2023 7:39 PM, Richard Damon wrote:
    On 1/29/23 8:23 PM, olcott wrote:
    On 1/29/2023 7:04 PM, Richard Damon wrote:
    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D and upon >>>>>>>> encountering the 8th line of D correctly determines that D would >>>>>>>> never
    stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual
    behavior of that call to H by D(D) will be to abort ITS
    simulation (which is a different instance, which is also an
    incorrect action) and return 0.

    Thus H gets the wrong answer because it presumes that H will not >>>>>>> get the wrong answer when it does.

    Until you provide the instruction in that direct execution of
    D(D) that differs from the execution of H(D,D) when called by
    main, you are just admitting that you are a Hypocritical
    Patholgical Lying Ignorant Idiot.


    In other words you are trying to get away with the counter-factual >>>>>> claim
    that D correctly simulated by H would eventually reach its own final >>>>>> state and terminate normally.

    D correctly siumulated will reach its own final state. This is
    shown by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change,

    When D is CORRECTLY SIMULATED BY H

    Which doesn't happen if H answers,

    Correctly and completely is not the same as correctly.

    It one instruction of D is correctly simulated then this one instruction
    <is> correctly simulated, likewise with more than one.

    *THIS IS PROVEN TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
    As long as H correctly simulates D until H has a correct basis to
    determine that D would never reach the final state of D then H has
    correctly determined that D is non-halting.



    --
    Copyright 2023 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 Sun Jan 29 20:54:18 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/29/23 8:43 PM, olcott wrote:
    On 1/29/2023 7:39 PM, Richard Damon wrote:
    On 1/29/23 8:23 PM, olcott wrote:
    On 1/29/2023 7:04 PM, Richard Damon wrote:
    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D and upon >>>>>>>>> encountering the 8th line of D correctly determines that D
    would never
    stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual
    behavior of that call to H by D(D) will be to abort ITS
    simulation (which is a different instance, which is also an
    incorrect action) and return 0.

    Thus H gets the wrong answer because it presumes that H will not >>>>>>>> get the wrong answer when it does.

    Until you provide the instruction in that direct execution of
    D(D) that differs from the execution of H(D,D) when called by
    main, you are just admitting that you are a Hypocritical
    Patholgical Lying Ignorant Idiot.


    In other words you are trying to get away with the
    counter-factual claim
    that D correctly simulated by H would eventually reach its own final >>>>>>> state and terminate normally.

    D correctly siumulated will reach its own final state. This is
    shown by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change,

    When D is CORRECTLY SIMULATED BY H

    Which doesn't happen if H answers,

    Correctly and completely is not the same as correctly.

    It is the only definition that lest you replace the behavior of the
    actual machine with a simulation.

    Since D(D) Halts, H(D,D) must return 1

    If you claim 0- is the correct answer, you question must be different
    and you have been lying all the time/.


    It one instruction of D is correctly simulated then this one instruction
    <is> correctly simulated, likewise with more than one.

    H, being a computation, must do the same thing for every invocation of
    it with the same parameter. Thus either ALL invocations to a "correct simulation" that doesn't abort (ad thus never answers), or NONE do so it
    can answer and you don't have a correct simulation to claim to base you
    answer on.

    You are just basing you logic an mythical magic fairy dust powered
    unicorns, which doesn't work to give consistent answers.


    *THIS IS PROVEN TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
    As long as H correctly simulates D until H has a correct basis to
    determine that D would never reach the final state of D then H has
    correctly determined that D is non-halting.


    But not the Technical meaning of the wornds.

    By the "Meaning of the words" since we can say:

    If this sentence is correct, Peter Olcott is a Hypocritical Pathological
    Lying Ignorat Idiot

    And since that sentence is true under the same use of meaning of the
    words as you are using.

    You are admitting that you ARE a Hypocritical Pathological Lying Ignornt
    Idiot.

    The problem is you are basing your "proof" on an assumption of a premise
    that can only be proven by assuming it to be true, This leads to a
    system subject to Curry's Paradox.

    Thus, your logic system is invalid.


    The fact that you repeat these same claims actually gives us the
    independent proof of the second clause, so we CAN logically say that you
    ARE a Hypocritical Pathological Lying Ignorant Idiot.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Sun Jan 29 20:24:51 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/29/2023 7:54 PM, Richard Damon wrote:
    On 1/29/23 8:43 PM, olcott wrote:
    On 1/29/2023 7:39 PM, Richard Damon wrote:
    On 1/29/23 8:23 PM, olcott wrote:
    On 1/29/2023 7:04 PM, Richard Damon wrote:
    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D and >>>>>>>>>> upon
    encountering the 8th line of D correctly determines that D >>>>>>>>>> would never
    stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual
    behavior of that call to H by D(D) will be to abort ITS
    simulation (which is a different instance, which is also an
    incorrect action) and return 0.

    Thus H gets the wrong answer because it presumes that H will >>>>>>>>> not get the wrong answer when it does.

    Until you provide the instruction in that direct execution of >>>>>>>>> D(D) that differs from the execution of H(D,D) when called by >>>>>>>>> main, you are just admitting that you are a Hypocritical
    Patholgical Lying Ignorant Idiot.


    In other words you are trying to get away with the
    counter-factual claim
    that D correctly simulated by H would eventually reach its own >>>>>>>> final
    state and terminate normally.

    D correctly siumulated will reach its own final state. This is
    shown by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change,

    When D is CORRECTLY SIMULATED BY H

    Which doesn't happen if H answers,

    Correctly and completely is not the same as correctly.

    It is the only definition that lest you replace the behavior of the
    actual machine with a simulation.

    Since D(D) Halts, H(D,D) must return 1

    If you claim 0- is the correct answer, you question must be different
    and you have been lying all the time/.


    It one instruction of D is correctly simulated then this one instruction
    <is> correctly simulated, likewise with more than one.

    H, being a computation, must do the same thing for every invocation of
    it with the same parameter.

    None-the-less we can both see that in the exhaustive set of possibilities:
    (a) H aborts the simulation of its input
    (b) H does not abort the simulation of its input
    D never reaches its final state, thus D never halts.

    I don't see what your thrill is to lie about this.


    --
    Copyright 2023 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 Sun Jan 29 21:48:12 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/29/23 9:24 PM, olcott wrote:
    On 1/29/2023 7:54 PM, Richard Damon wrote:
    On 1/29/23 8:43 PM, olcott wrote:
    On 1/29/2023 7:39 PM, Richard Damon wrote:
    On 1/29/23 8:23 PM, olcott wrote:
    On 1/29/2023 7:04 PM, Richard Damon wrote:
    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D and >>>>>>>>>>> upon
    encountering the 8th line of D correctly determines that D >>>>>>>>>>> would never
    stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual
    behavior of that call to H by D(D) will be to abort ITS
    simulation (which is a different instance, which is also an >>>>>>>>>> incorrect action) and return 0.

    Thus H gets the wrong answer because it presumes that H will >>>>>>>>>> not get the wrong answer when it does.

    Until you provide the instruction in that direct execution of >>>>>>>>>> D(D) that differs from the execution of H(D,D) when called by >>>>>>>>>> main, you are just admitting that you are a Hypocritical
    Patholgical Lying Ignorant Idiot.


    In other words you are trying to get away with the
    counter-factual claim
    that D correctly simulated by H would eventually reach its own >>>>>>>>> final
    state and terminate normally.

    D correctly siumulated will reach its own final state. This is >>>>>>>> shown by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change,

    When D is CORRECTLY SIMULATED BY H

    Which doesn't happen if H answers,

    Correctly and completely is not the same as correctly.

    It is the only definition that lest you replace the behavior of the
    actual machine with a simulation.

    Since D(D) Halts, H(D,D) must return 1

    If you claim 0- is the correct answer, you question must be different
    and you have been lying all the time/.


    It one instruction of D is correctly simulated then this one instruction >>> <is> correctly simulated, likewise with more than one.

    H, being a computation, must do the same thing for every invocation of
    it with the same parameter.

    None-the-less we can both see that in the exhaustive set of possibilities:

    None-the-less: Translate, Peter Olcott will avoid valid logic and make
    an fabricated statement.

    (a) H aborts the simulation of its input
    (Which it does)
    (b) H does not abort the simulation of its input
    D never reaches its final state, thus D never halts.

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
    final state.

    Remember, the question is NOT "Does H simulate to the final state" but
    does the machine represented by the input reach a final state.

    Also, if H doesn't abort its simulation, it isn't the machine you are
    thinking of, as it never returns an answer, and thus fails to be the
    decider needed. Since you are talking about an H that DOES abort its simulation, case (b) is not available as a possible behavior for the H
    that D calls.

    At least until you show the instruction of different behavior on the two
    paths of direct execution, which you haven't so you have admitted to
    being the Hypocritical Pathological Lying Ignorant Idiot.


    I don't see what your thrill is to lie about this.


    So, you are caught in your lie again.

    D(D) will Halt because H(D,D) WILL return 0, thus H(D,D) returning 0 is
    an incorrecxt answer for the ACTUAL Halting problem which asks about
    that direct exectuion, not your fantasy condition of "a correct
    simulation by H".

    Your repeating this statement just proves you are that Hypocritical Pathological Lying Ignorant Idiot.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Sun Jan 29 23:11:01 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/29/2023 8:48 PM, Richard Damon wrote:
    On 1/29/23 9:24 PM, olcott wrote:
    On 1/29/2023 7:54 PM, Richard Damon wrote:
    On 1/29/23 8:43 PM, olcott wrote:
    On 1/29/2023 7:39 PM, Richard Damon wrote:
    On 1/29/23 8:23 PM, olcott wrote:
    On 1/29/2023 7:04 PM, Richard Damon wrote:
    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D >>>>>>>>>>>> and upon
    encountering the 8th line of D correctly determines that D >>>>>>>>>>>> would never
    stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual >>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS
    simulation (which is a different instance, which is also an >>>>>>>>>>> incorrect action) and return 0.

    Thus H gets the wrong answer because it presumes that H will >>>>>>>>>>> not get the wrong answer when it does.

    Until you provide the instruction in that direct execution of >>>>>>>>>>> D(D) that differs from the execution of H(D,D) when called by >>>>>>>>>>> main, you are just admitting that you are a Hypocritical >>>>>>>>>>> Patholgical Lying Ignorant Idiot.


    In other words you are trying to get away with the
    counter-factual claim
    that D correctly simulated by H would eventually reach its own >>>>>>>>>> final
    state and terminate normally.

    D correctly siumulated will reach its own final state. This is >>>>>>>>> shown by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change,

    When D is CORRECTLY SIMULATED BY H

    Which doesn't happen if H answers,

    Correctly and completely is not the same as correctly.

    It is the only definition that lest you replace the behavior of the
    actual machine with a simulation.

    Since D(D) Halts, H(D,D) must return 1

    If you claim 0- is the correct answer, you question must be different
    and you have been lying all the time/.


    It one instruction of D is correctly simulated then this one
    instruction
    <is> correctly simulated, likewise with more than one.

    H, being a computation, must do the same thing for every invocation
    of it with the same parameter.

    None-the-less we can both see that in the exhaustive set of
    possibilities:

    None-the-less: Translate, Peter Olcott will avoid valid logic and make
    an fabricated statement.

    (a) H aborts the simulation of its input
    (Which it does)
    (b) H does not abort the simulation of its input
    D never reaches its final state, thus D never halts.

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
    final state.


    You know that D correctly simulated by H cannot possibly reach the final
    state of D and lie about this because you think that lying is funny.


    --
    Copyright 2023 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 Python on Sun Jan 29 23:43:48 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/29/2023 11:27 PM, Python wrote:
    Le 30/01/2023 à 06:11, olcott a écrit :
    On 1/29/2023 8:48 PM, Richard Damon wrote:
    On 1/29/23 9:24 PM, olcott wrote:
    On 1/29/2023 7:54 PM, Richard Damon wrote:
    On 1/29/23 8:43 PM, olcott wrote:
    On 1/29/2023 7:39 PM, Richard Damon wrote:
    On 1/29/23 8:23 PM, olcott wrote:
    On 1/29/2023 7:04 PM, Richard Damon wrote:
    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D >>>>>>>>>>>>>> and upon
    encountering the 8th line of D correctly determines that D >>>>>>>>>>>>>> would never
    stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual >>>>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS >>>>>>>>>>>>> simulation (which is a different instance, which is also an >>>>>>>>>>>>> incorrect action) and return 0.

    Thus H gets the wrong answer because it presumes that H >>>>>>>>>>>>> will not get the wrong answer when it does.

    Until you provide the instruction in that direct execution >>>>>>>>>>>>> of D(D) that differs from the execution of H(D,D) when >>>>>>>>>>>>> called by main, you are just admitting that you are a >>>>>>>>>>>>> Hypocritical Patholgical Lying Ignorant Idiot.


    In other words you are trying to get away with the
    counter-factual claim
    that D correctly simulated by H would eventually reach its >>>>>>>>>>>> own final
    state and terminate normally.

    D correctly siumulated will reach its own final state. This >>>>>>>>>>> is shown by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change,

    When D is CORRECTLY SIMULATED BY H

    Which doesn't happen if H answers,

    Correctly and completely is not the same as correctly.

    It is the only definition that lest you replace the behavior of the
    actual machine with a simulation.

    Since D(D) Halts, H(D,D) must return 1

    If you claim 0- is the correct answer, you question must be
    different and you have been lying all the time/.


    It one instruction of D is correctly simulated then this one
    instruction
    <is> correctly simulated, likewise with more than one.

    H, being a computation, must do the same thing for every invocation
    of it with the same parameter.

    None-the-less we can both see that in the exhaustive set of
    possibilities:

    None-the-less: Translate, Peter Olcott will avoid valid logic and
    make an fabricated statement.

    (a) H aborts the simulation of its input
    (Which it does)
    (b) H does not abort the simulation of its input
    D never reaches its final state, thus D never halts.

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
    its final state.


    You know that D correctly simulated by H cannot possibly reach the final
    state of D and lie about this because you think that lying is funny.

    You are the one lying, and it is not funny.

    Anyone that knows these things knows that I am correct.
    You cannot point out any mistake because there are none.

    --
    Copyright 2023 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 Python@21:1/5 to All on Mon Jan 30 06:27:20 2023
    XPost: comp.theory, sci.logic, sci.math

    Le 30/01/2023 à 06:11, olcott a écrit :
    On 1/29/2023 8:48 PM, Richard Damon wrote:
    On 1/29/23 9:24 PM, olcott wrote:
    On 1/29/2023 7:54 PM, Richard Damon wrote:
    On 1/29/23 8:43 PM, olcott wrote:
    On 1/29/2023 7:39 PM, Richard Damon wrote:
    On 1/29/23 8:23 PM, olcott wrote:
    On 1/29/2023 7:04 PM, Richard Damon wrote:
    On 1/29/23 7:15 PM, olcott wrote:
    On 1/28/2023 9:44 PM, Richard Damon wrote:
    On 1/28/23 6:29 PM, olcott wrote:
    On 1/27/2023 10:21 PM, Richard Damon wrote:
    On 1/27/23 11:14 PM, olcott wrote:
    H does a correct simulation of the first seven lines of D >>>>>>>>>>>>> and upon
    encountering the 8th line of D correctly determines that D >>>>>>>>>>>>> would never
    stop running unless aborted.

    Nope, that is an INCORRECT conclusion, because the actual >>>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS >>>>>>>>>>>> simulation (which is a different instance, which is also an >>>>>>>>>>>> incorrect action) and return 0.

    Thus H gets the wrong answer because it presumes that H will >>>>>>>>>>>> not get the wrong answer when it does.

    Until you provide the instruction in that direct execution >>>>>>>>>>>> of D(D) that differs from the execution of H(D,D) when >>>>>>>>>>>> called by main, you are just admitting that you are a
    Hypocritical Patholgical Lying Ignorant Idiot.


    In other words you are trying to get away with the
    counter-factual claim
    that D correctly simulated by H would eventually reach its >>>>>>>>>>> own final
    state and terminate normally.

    D correctly siumulated will reach its own final state. This is >>>>>>>>>> shown by UTM(D,D).
    You dishonestly changed the words. Why lie?

    No, YOU are o=one making the change,

    When D is CORRECTLY SIMULATED BY H

    Which doesn't happen if H answers,

    Correctly and completely is not the same as correctly.

    It is the only definition that lest you replace the behavior of the
    actual machine with a simulation.

    Since D(D) Halts, H(D,D) must return 1

    If you claim 0- is the correct answer, you question must be
    different and you have been lying all the time/.


    It one instruction of D is correctly simulated then this one
    instruction
    <is> correctly simulated, likewise with more than one.

    H, being a computation, must do the same thing for every invocation
    of it with the same parameter.

    None-the-less we can both see that in the exhaustive set of
    possibilities:

    None-the-less: Translate, Peter Olcott will avoid valid logic and make
    an fabricated statement.

    (a) H aborts the simulation of its input
    (Which it does)
    (b) H does not abort the simulation of its input
    D never reaches its final state, thus D never halts.

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
    final state.


    You know that D correctly simulated by H cannot possibly reach the final state of D and lie about this because you think that lying is funny.

    You are the one lying, and it is not funny.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Mon Jan 30 06:58:43 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/30/23 12:43 AM, olcott wrote:
    On 1/29/2023 11:27 PM, Python wrote:
    Le 30/01/2023 à 06:11, olcott a écrit :
    On 1/29/2023 8:48 PM, Richard Damon wrote:
    On 1/29/23 9:24 PM, olcott wrote:
    D never reaches its final state, thus D never halts.

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
    its final state.


    You know that D correctly simulated by H cannot possibly reach the final >>> state of D and lie about this because you think that lying is funny.

    You are the one lying, and it is not funny.

    Anyone that knows these things knows that I am correct.
    You cannot point out any mistake because there are none.


    No, EVERYONE who knows even the littlest bit of the theory knows you are
    just wrong.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Mon Jan 30 06:57:37 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/30/23 12:11 AM, olcott wrote:
    On 1/29/2023 8:48 PM, Richard Damon wrote:

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
    final state.


    You know that D correctly simulated by H cannot possibly reach the final state of D and lie about this because you think that lying is funny.


    Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
    you stopped beating your wife?"

    H is a DEFINIED function, you H ALWAYS aborts this D when it simulates,
    so it NEVER does a complete and correct simulation of the input.

    Also, you are asking the wrong queztion, it isn't if the simulation done
    by H can reach the final state, but does D(D) when run reach its final
    state.

    The fact that H aborts its simulation says the question of did its
    simulation reach the final state is just moot. That is like claimin you
    can measure how long a road is by driving the first mile and then
    getting off.

    You are showing that you fundamentally don't understand ANY of the logic theory, or how computers work, either you are totally ignorant, or you
    are just a pathological liar (because you know the right answer but
    won't accept it) or both.

    Since you have AGREED that D(D) when dirrectly run will return, then the correct answer to the question of the Halting Program for D(D), "Will
    this input when directly run Halt?" is yes.

    The fact that you try to claim that No could be a correct answer just
    shows how much you don't care about what it true.

    You are just a pitiful hypociritcal pathological lying ignorant idiot
    that has doomed himself for all eternity to be remembered for the dolt
    he his.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Mon Jan 30 09:31:42 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/30/2023 5:57 AM, Richard Damon wrote:
    On 1/30/23 12:11 AM, olcott wrote:
    On 1/29/2023 8:48 PM, Richard Damon wrote:

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
    its final state.


    You know that D correctly simulated by H cannot possibly reach the final
    state of D and lie about this because you think that lying is funny.


    Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
    you stopped beating your wife?"


    Because HH does faithfully simulate the first 8 instructions of PP we
    know that the simulation of these first 8 instructions is correct.

    Begin Local Halt Decider Simulation Executio Trace Stored at:112aa9
    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= ============= [00001993][00112a95][00112a99] 55 push ebp // begin PP [00001994][00112a95][00112a99] 8bec mov ebp,esp [00001996][00112a91][00102a65] 51 push ecx [00001997][00112a91][00102a65] 8b4508 mov eax,[ebp+08] [0000199a][00112a8d][00001993] 50 push eax // push PP [0000199b][00112a8d][00001993] 8b4d08 mov ecx,[ebp+08] [0000199e][00112a89][00001993] 51 push ecx // push PP [0000199f][00112a85][000019a4] e8fff7ffff call 000011a3 // call HH
    New slave_stack at:14d4c9
    [00001993][0015d4bd][0015d4c1] 55 push ebp // begin PP [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp [00001996][0015d4b9][0014d48d] 51 push ecx [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08] [0000199a][0015d4b5][00001993] 50 push eax // push PP [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51 push ecx // push PP [0000199f][0015d4ad][000019a4] e8fff7ffff call 000011a3 // call HH
    Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    Everyone can see that this does cause the same 8 instructions of PP to
    be repeated and everyone can see that there are no instructions in PP
    that would prevent this from infinitely repeating.

    That you lie about this is despicable.


    --
    Copyright 2023 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 Richard Damon on Mon Jan 30 09:42:49 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/30/2023 5:58 AM, Richard Damon wrote:
    On 1/30/23 12:43 AM, olcott wrote:
    On 1/29/2023 11:27 PM, Python wrote:
    Le 30/01/2023 à 06:11, olcott a écrit :
    On 1/29/2023 8:48 PM, Richard Damon wrote:
    On 1/29/23 9:24 PM, olcott wrote:
    D never reaches its final state, thus D never halts.

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
    its final state.


    You know that D correctly simulated by H cannot possibly reach the
    final
    state of D and lie about this because you think that lying is funny.

    You are the one lying, and it is not funny.

    Anyone that knows these things knows that I am correct.
    You cannot point out any mistake because there are none.


    No, EVERYONE who knows even the littlest bit of the theory knows you are
    just wrong.

    Everyone that knows a little bit about theory presumes that I am wrong
    either without looking at what I say or by looking at what I say and
    ignoring it. ChatGPT determined that my argument is valid.

    olcott
    This first sentence is an established fact: When H(D,D) correctly
    simulates its input the execution trace of this simulated input proves
    that it would never stop running because D continues to call H in
    recursive simulation. Then H aborts its simulation of D and returns 0 to
    main, indicating that D would never stop running unless aborted. Is H
    correct?

    ChatGPT correctly determined that my second sentence follows from my
    first sentence by logical necessity. You were unable to comprehend this elementary rule of logical deduction.

    Begin Local Halt Decider Simulation Execution Trace Stored at:112aa9
    machine stack stack machine assembly
    address address data code language
    ======== ======== ======== ========= ============= [00001993][00112a95][00112a99] 55 push ebp // begin PP [00001994][00112a95][00112a99] 8bec mov ebp,esp [00001996][00112a91][00102a65] 51 push ecx [00001997][00112a91][00102a65] 8b4508 mov eax,[ebp+08] [0000199a][00112a8d][00001993] 50 push eax // push PP [0000199b][00112a8d][00001993] 8b4d08 mov ecx,[ebp+08] [0000199e][00112a89][00001993] 51 push ecx // push PP [0000199f][00112a85][000019a4] e8fff7ffff call 000011a3 // call HH
    New slave_stack at:14d4c9
    [00001993][0015d4bd][0015d4c1] 55 push ebp // begin PP [00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp [00001996][0015d4b9][0014d48d] 51 push ecx [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08] [0000199a][0015d4b5][00001993] 50 push eax // push PP [0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51 push ecx // push PP [0000199f][0015d4ad][000019a4] e8fff7ffff call 000011a3 // call HH
    Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    Analysis of the above conclusively proves that HH did correctly simulate
    PP until HH correctly determined that PP could not possibly reach its
    own final state and terminate normally.

    --
    Copyright 2023 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 Mon Jan 30 18:43:08 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/30/23 10:31 AM, olcott wrote:
    On 1/30/2023 5:57 AM, Richard Damon wrote:
    On 1/30/23 12:11 AM, olcott wrote:
    On 1/29/2023 8:48 PM, Richard Damon wrote:

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
    its final state.


    You know that D correctly simulated by H cannot possibly reach the final >>> state of D and lie about this because you think that lying is funny.


    Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
    you stopped beating your wife?"


    Because HH does faithfully simulate the first 8 instructions of PP we
    know that the simulation of these first 8 instructions is correct.


    SS, the first mile of a road doesn't tell you how long it is.

    Also, it is debatable if the 8th instruction was simulated correctly, as
    the "machine" state after it doesn't match what actually haooens (the
    continued execution of the function HH)

    Begin Local Halt Decider Simulation   Executio Trace Stored at:112aa9
     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  ============= [00001993][00112a95][00112a99] 55             push ebp      // begin PP
    [00001994][00112a95][00112a99] 8bec           mov ebp,esp [00001996][00112a91][00102a65] 51             push ecx [00001997][00112a91][00102a65] 8b4508         mov eax,[ebp+08] [0000199a][00112a8d][00001993] 50             push eax      // push PP
    [0000199b][00112a8d][00001993] 8b4d08         mov ecx,[ebp+08] [0000199e][00112a89][00001993] 51             push ecx      // push PP
    [0000199f][00112a85][000019a4] e8fff7ffff     call 000011a3 // call HH New slave_stack at:14d4c9
    [00001993][0015d4bd][0015d4c1] 55             push ebp      // begin PP
    [00001994][0015d4bd][0015d4c1] 8bec           mov ebp,esp [00001996][0015d4b9][0014d48d] 51             push ecx [00001997][0015d4b9][0014d48d] 8b4508         mov eax,[ebp+08] [0000199a][0015d4b5][00001993] 50             push eax      // push PP
    [0000199b][0015d4b5][00001993] 8b4d08         mov ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51             push ecx      // push PP
    [0000199f][0015d4ad][000019a4] e8fff7ffff     call 000011a3 // call HH Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    Everyone can see that this does cause the same 8 instructions of PP to
    be repeated and everyone can see that there are no instructions in PP
    that would prevent this from infinitely repeating.


    But after the call HH should be the instruciton of HH, so the simulation
    is incorrect.

    That you lie about this is despicable.



    YOU are the liar

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Mon Jan 30 22:07:25 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/30/2023 5:43 PM, Richard Damon wrote:
    On 1/30/23 10:31 AM, olcott wrote:
    On 1/30/2023 5:57 AM, Richard Damon wrote:
    On 1/30/23 12:11 AM, olcott wrote:
    On 1/29/2023 8:48 PM, Richard Damon wrote:

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
    its final state.


    You know that D correctly simulated by H cannot possibly reach the
    final
    state of D and lie about this because you think that lying is funny.


    Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
    you stopped beating your wife?"


    Because HH does faithfully simulate the first 8 instructions of PP we
    know that the simulation of these first 8 instructions is correct.


    SS, the first mile of a road doesn't tell you how long it is.

    Also, it is debatable if the 8th instruction was simulated correctly, as
    the "machine" state after it doesn't match what actually haooens (the continued execution of the function HH)

    Begin Local Halt Decider Simulation   Executio Trace Stored at:112aa9
      machine   stack     stack     machine    assembly
      address   address   data      code       language
      ========  ========  ========  =========  =============
    [00001993][00112a95][00112a99] 55             push ebp      // begin PP
    [00001994][00112a95][00112a99] 8bec           mov ebp,esp
    [00001996][00112a91][00102a65] 51             push ecx
    [00001997][00112a91][00102a65] 8b4508         mov eax,[ebp+08]
    [0000199a][00112a8d][00001993] 50             push eax      // push PP
    [0000199b][00112a8d][00001993] 8b4d08         mov ecx,[ebp+08]
    [0000199e][00112a89][00001993] 51             push ecx      // push PP
    [0000199f][00112a85][000019a4] e8fff7ffff     call 000011a3 // call HH >> New slave_stack at:14d4c9
    [00001993][0015d4bd][0015d4c1] 55             push ebp      // begin PP
    [00001994][0015d4bd][0015d4c1] 8bec           mov ebp,esp
    [00001996][0015d4b9][0014d48d] 51             push ecx
    [00001997][0015d4b9][0014d48d] 8b4508         mov eax,[ebp+08]
    [0000199a][0015d4b5][00001993] 50             push eax      // push PP
    [0000199b][0015d4b5][00001993] 8b4d08         mov ecx,[ebp+08]
    [0000199e][0015d4b1][00001993] 51             push ecx      // push PP
    [0000199f][0015d4ad][000019a4] e8fff7ffff     call 000011a3 // call HH >> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    Everyone can see that this does cause the same 8 instructions of PP to
    be repeated and everyone can see that there are no instructions in PP
    that would prevent this from infinitely repeating.


    But after the call HH should be the instruciton of HH, so the simulation
    is incorrect.


    It is not that the execution trace is incorrect I simply do not show
    the other 251 pages of execution trace. HH knows its own behavior so it
    does not look at its simulated self. It still does simulate itself that
    is why it takes 251 more pages.

    --
    Copyright 2023 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 Mon Jan 30 23:16:56 2023
    XPost: comp.theory, sci.logic, sci.math

    On 1/30/23 11:07 PM, olcott wrote:
    On 1/30/2023 5:43 PM, Richard Damon wrote:
    On 1/30/23 10:31 AM, olcott wrote:
    On 1/30/2023 5:57 AM, Richard Damon wrote:
    On 1/30/23 12:11 AM, olcott wrote:
    On 1/29/2023 8:48 PM, Richard Damon wrote:

    Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches >>>>>> its final state.


    You know that D correctly simulated by H cannot possibly reach the
    final
    state of D and lie about this because you think that lying is funny. >>>>>

    Sincd H doesn't correctlyh simu.ate D(D), that sentence is like
    "Have you stopped beating your wife?"


    Because HH does faithfully simulate the first 8 instructions of PP we
    know that the simulation of these first 8 instructions is correct.


    SS, the first mile of a road doesn't tell you how long it is.

    Also, it is debatable if the 8th instruction was simulated correctly,
    as the "machine" state after it doesn't match what actually haooens
    (the continued execution of the function HH)

    Begin Local Halt Decider Simulation   Executio Trace Stored at:112aa9
      machine   stack     stack     machine    assembly
      address   address   data      code       language
      ========  ========  ========  =========  =============
    [00001993][00112a95][00112a99] 55             push ebp      // begin PP
    [00001994][00112a95][00112a99] 8bec           mov ebp,esp
    [00001996][00112a91][00102a65] 51             push ecx
    [00001997][00112a91][00102a65] 8b4508         mov eax,[ebp+08]
    [0000199a][00112a8d][00001993] 50             push eax      // push PP
    [0000199b][00112a8d][00001993] 8b4d08         mov ecx,[ebp+08]
    [0000199e][00112a89][00001993] 51             push ecx      // push PP
    [0000199f][00112a85][000019a4] e8fff7ffff     call 000011a3 // call HH >>> New slave_stack at:14d4c9
    [00001993][0015d4bd][0015d4c1] 55             push ebp      // begin PP
    [00001994][0015d4bd][0015d4c1] 8bec           mov ebp,esp
    [00001996][0015d4b9][0014d48d] 51             push ecx
    [00001997][0015d4b9][0014d48d] 8b4508         mov eax,[ebp+08]
    [0000199a][0015d4b5][00001993] 50             push eax      // push PP
    [0000199b][0015d4b5][00001993] 8b4d08         mov ecx,[ebp+08]
    [0000199e][0015d4b1][00001993] 51             push ecx      // push PP
    [0000199f][0015d4ad][000019a4] e8fff7ffff     call 000011a3 // call HH >>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    Everyone can see that this does cause the same 8 instructions of PP to
    be repeated and everyone can see that there are no instructions in PP
    that would prevent this from infinitely repeating.


    But after the call HH should be the instruciton of HH, so the
    simulation is incorrect.


    It is not that the execution trace is incorrect I simply do not show
    the other 251 pages of execution trace. HH knows its own behavior so it
    does not look at its simulated self. It still does simulate itself that
    is why it takes 251 more pages.


    But the actual execution trace never gets into another copy of D, as all
    that happens is that H simulates those instruction, they never actually
    get executed as an "program"

    Even if done via a Step with Debug exception, then every instruction is seperated by the code of the tracing.

    Thus, it is INCORRECT.


    You apparently don't understand the difference between a direct
    execution and a simulation.

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