1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: Olcott seems to be willfully ignorant

    From joes@21:1/5 to All on Wed Jul 3 14:16:16 2024
    Am Wed, 03 Jul 2024 08:27:40 -0500 schrieb olcott:
    On 7/3/2024 6:44 AM, Richard Damon wrote:
    On 7/2/24 11:43 PM, olcott wrote:
    On 7/2/2024 10:23 PM, Richard Damon wrote:
    On 7/2/24 11:07 PM, olcott wrote:
    On 7/2/2024 9:35 PM, Richard Damon wrote:
    On 7/2/24 10:03 PM, olcott wrote:
    On 7/2/2024 8:51 PM, Richard Damon wrote:
    On 7/2/24 9:32 PM, olcott wrote:
    On 7/2/2024 8:25 PM, Richard Damon wrote:
    On 7/2/24 9:18 PM, olcott wrote:

    YOU are just a liar, as proved by the fact that you can not >>>>>>>>>> give the Diagonalization proof you claimed you had.

    But I am NOT disagreeing with the x86 language.
    Can you point out what fact of it I am disagreing about it?

    Nope, and x86n emulation is only fully correct if it continues to
    the final end.

    Why do you say such ridiculously stupid things that you are are
    false?
    And the only CORRECT EMULATION of that program is to infiniately loop
    in the emulation.
    Not for a freaking termination analyzer nitwit.
    Why do they get to lie?
    Open question.

    Nothing says that you can't make a halt decider work with partial
    emulation for SOME inputs. But the halt Decider just isn't itself a
    fully correct emulator.
    You keep stupidly saying that less than an infinite emulation is an
    incorrect emulation. Why do you keep stupidly doing that?
    Because it is. Partial emulations only show partial truth, and truth is
    the whole truth and nothing but the truth.
    BEHAVIOR needs the FULL description of what happens.

    Why do you keep lying about this?
    As soon as HHH has seen a repeating state it has seen enough.
    If the state is actually the same. But the simulated HHH sets a flag
    or something to keep track if it is itself simulating a repetition. <-
    Which it therefore isn’t.

    --
    Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
    Objectively I am a genius.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Wed Jul 3 17:40:21 2024
    Op 03.jul.2024 om 16:29 schreef olcott:
    On 7/3/2024 9:16 AM, joes wrote:
    Am Wed, 03 Jul 2024 08:27:40 -0500 schrieb olcott:
    On 7/3/2024 6:44 AM, Richard Damon wrote:
    On 7/2/24 11:43 PM, olcott wrote:
    On 7/2/2024 10:23 PM, Richard Damon wrote:
    On 7/2/24 11:07 PM, olcott wrote:
    On 7/2/2024 9:35 PM, Richard Damon wrote:
    On 7/2/24 10:03 PM, olcott wrote:
    On 7/2/2024 8:51 PM, Richard Damon wrote:
    On 7/2/24 9:32 PM, olcott wrote:
    On 7/2/2024 8:25 PM, Richard Damon wrote:
    On 7/2/24 9:18 PM, olcott wrote:

    YOU are just a liar, as proved by the fact that you can not >>>>>>>>>>>> give the Diagonalization proof you claimed you had.

    But I am NOT disagreeing with the x86 language.
    Can you point out what fact of it I am disagreing about it? >>>>>>>>>>
    Nope, and x86n emulation is only fully correct if it continues to >>>>>>>> the final end.

    Why do you say such ridiculously stupid things that you are are
    false?
    And the only CORRECT EMULATION of that program is to infiniately loop >>>>>> in the emulation.
    Not for a freaking termination analyzer nitwit.
    Why do they get to lie?
    Open question.

    Nothing says that you can't make a halt decider work with partial
    emulation for SOME inputs. But the halt Decider just isn't itself a >>>>>> fully correct emulator.
    You keep stupidly saying that less than an infinite emulation is an
    incorrect emulation. Why do you keep stupidly doing that?
    Because it is. Partial emulations only show partial truth, and truth is >>>> the whole truth and nothing but the truth.
    BEHAVIOR needs the FULL description of what happens.

    Why do you keep lying about this?
    As soon as HHH has seen a repeating state it has seen enough.
    If the state is actually the same. But the simulated HHH sets a flag
    or something to keep track if it is itself simulating a repetition. <-
    Which it therefore isn’t.


    _DDD()
    [00002172] 55         push ebp      ; housekeeping
    [00002173] 8bec       mov ebp,esp   ; housekeeping
    [00002175] 6872210000 push 00002172 ; push DDD
    [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
    [0000217f] 83c404     add esp,+04
    [00002182] 5d         pop ebp
    [00002183] c3         ret
    Size in bytes:(0018) [00002183]

    *This is the repeating state*

    But not an *infinitely* repeating state. HHH simulates only two cycles.
    When it aborts itself, the simulated HHH has only one cycle to go.
    A correct simulation of HHH (by another simulator) shows that it halts. However, HHH is not able to perform a similar correct simulation of itself.

    Begin Local Halt Decider Simulation   Execution Trace Stored at:1138cc [00002172][001138bc][001138c0] 55         push ebp      ; housekeeping
    [00002173][001138bc][001138c0] 8bec       mov ebp,esp   ; housekeeping
    [00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
    New slave_stack at:14e2ec
    [00002172][0015e2e4][0015e2e8] 55         push ebp      ; housekeeping
    [00002173][0015e2e4][0015e2e8] 8bec       mov ebp,esp   ; housekeeping
    [00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
    Local Halt Decider: Infinite Recursion Detected Simulation Stopped

    Incorrect conclusion that it detects an infinite Recursion. It is only a
    two cycle recursion. So, the abort was premature.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From joes@21:1/5 to All on Thu Jul 4 10:20:55 2024
    Am Wed, 03 Jul 2024 10:51:40 -0500 schrieb olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 16:29 schreef olcott:
    On 7/3/2024 9:16 AM, joes wrote:
    Am Wed, 03 Jul 2024 08:27:40 -0500 schrieb olcott:
    On 7/3/2024 6:44 AM, Richard Damon wrote:
    On 7/2/24 11:43 PM, olcott wrote:
    On 7/2/2024 10:23 PM, Richard Damon wrote:
    On 7/2/24 11:07 PM, olcott wrote:
    On 7/2/2024 9:35 PM, Richard Damon wrote:
    On 7/2/24 10:03 PM, olcott wrote:
    On 7/2/2024 8:51 PM, Richard Damon wrote:
    On 7/2/24 9:32 PM, olcott wrote:
    On 7/2/2024 8:25 PM, Richard Damon wrote:
    On 7/2/24 9:18 PM, olcott wrote:

    And the only CORRECT EMULATION of that program is to infiniately >>>>>>>> loop in the emulation.
    Not for a freaking termination analyzer nitwit.
    Why do they get to lie?
    Open question.

    Nothing says that you can't make a halt decider work with partial >>>>>>>> emulation for SOME inputs. But the halt Decider just isn't itself >>>>>>>> a fully correct emulator.
    You keep stupidly saying that less than an infinite emulation is >>>>>>> an incorrect emulation. Why do you keep stupidly doing that?
    Because it is. Partial emulations only show partial truth, and
    truth is the whole truth and nothing but the truth.
    BEHAVIOR needs the FULL description of what happens.

    Why do you keep lying about this?
    As soon as HHH has seen a repeating state it has seen enough.
    If the state is actually the same. But the simulated HHH sets a flag
    or something to keep track if it is itself simulating a repetition.
    <- Which it therefore isn’t.

    *This is the repeating state*
    But not an *infinitely* repeating state.

    The criteria that I spent two years writing and the best selling author
    of theory of computation textbooks agrees with says nothing about *infinitely* repeating state.
    If the state doesn’t repeat infinitely often, it is not the same state
    and does halt.

    --
    Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
    Objectively I am a genius.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From joes@21:1/5 to All on Thu Jul 4 13:36:02 2024
    Am Thu, 04 Jul 2024 07:48:08 -0500 schrieb olcott:
    On 7/4/2024 5:20 AM, joes wrote:
    Am Wed, 03 Jul 2024 10:51:40 -0500 schrieb olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 16:29 schreef olcott:
    On 7/3/2024 9:16 AM, joes wrote:
    Am Wed, 03 Jul 2024 08:27:40 -0500 schrieb olcott:
    On 7/3/2024 6:44 AM, Richard Damon wrote:
    On 7/2/24 11:43 PM, olcott wrote:
    On 7/2/2024 10:23 PM, Richard Damon wrote:
    On 7/2/24 11:07 PM, olcott wrote:
    On 7/2/2024 9:35 PM, Richard Damon wrote:
    On 7/2/24 10:03 PM, olcott wrote:
    On 7/2/2024 8:51 PM, Richard Damon wrote:
    On 7/2/24 9:32 PM, olcott wrote:
    On 7/2/2024 8:25 PM, Richard Damon wrote:
    On 7/2/24 9:18 PM, olcott wrote:
    And the only CORRECT EMULATION of that program is to
    infiniately loop in the emulation.
    Not for a freaking termination analyzer nitwit.
    Why do they get to lie?
    Open question.
    Why can a termination analyser emulate an infinite loop as a finite one?

    Nothing says that you can't make a halt decider work with
    partial emulation for SOME inputs. But the halt Decider just >>>>>>>>>> isn't itself a fully correct emulator.
    BEHAVIOR needs the FULL description of what happens.
    As soon as HHH has seen a repeating state it has seen enough.
    If the state is actually the same. But the simulated HHH sets a
    flag or something to keep track if it is itself simulating a
    repetition. <- Which it therefore isn’t.
    How does HHH track it?

    *This is the repeating state*
    But not an *infinitely* repeating state.
    The criteria that I spent two years writing and the best selling
    author of theory of computation textbooks agrees with says nothing
    about *infinitely* repeating state.
    If the state doesn’t repeat infinitely often, it is not the same state
    and does halt.
    „State” does not mean calling the same function again. It means the same stack, registers and memory, or for TMs, same tape and internal status.
    If that reappears, there can be no deviation, because those completely determine program flow.
    H does not call D, it only simulates part of it, until before the
    recursive call to H aborts.

    It took me two years to come up with these words please make sure that
    you totally understand each one of them.
    I do. It is not very difficult. The point is that H doesn’t simulate D correctly: D halts, because it only calls H, which halts by definition.

    --
    Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
    Objectively I am a genius.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jul 4 11:25:15 2024
    On 7/4/24 8:48 AM, olcott wrote:
    On 7/4/2024 5:20 AM, joes wrote:
    Am Wed, 03 Jul 2024 10:51:40 -0500 schrieb olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 16:29 schreef olcott:
    On 7/3/2024 9:16 AM, joes wrote:
    Am Wed, 03 Jul 2024 08:27:40 -0500 schrieb olcott:
    On 7/3/2024 6:44 AM, Richard Damon wrote:
    On 7/2/24 11:43 PM, olcott wrote:
    On 7/2/2024 10:23 PM, Richard Damon wrote:
    On 7/2/24 11:07 PM, olcott wrote:
    On 7/2/2024 9:35 PM, Richard Damon wrote:
    On 7/2/24 10:03 PM, olcott wrote:
    On 7/2/2024 8:51 PM, Richard Damon wrote:
    On 7/2/24 9:32 PM, olcott wrote:
    On 7/2/2024 8:25 PM, Richard Damon wrote:
    On 7/2/24 9:18 PM, olcott wrote:

    And the only CORRECT EMULATION of that program is to infiniately >>>>>>>>>> loop in the emulation.
    Not for a freaking termination analyzer nitwit.
    Why do they get to lie?
    Open question.

    Nothing says that you can't make a halt decider work with partial >>>>>>>>>> emulation for SOME inputs. But the halt Decider just isn't itself >>>>>>>>>> a fully correct emulator.
    You keep stupidly saying that less than an infinite emulation is >>>>>>>>> an incorrect emulation. Why do you keep stupidly doing that?
    Because it is. Partial emulations only show partial truth, and >>>>>>>> truth is the whole truth and nothing but the truth.
    BEHAVIOR needs the FULL description of what happens.

    Why do you keep lying about this?
    As soon as HHH has seen a repeating state it has seen enough.
    If the state is actually the same. But the simulated HHH sets a flag >>>>>> or something to keep track if it is itself simulating a repetition. >>>>>> <- Which it therefore isn’t.

    *This is the repeating state*
    But not an *infinitely* repeating state.

    The criteria that I spent two years writing and the best selling author
    of theory of computation textbooks agrees with says nothing about
    *infinitely* repeating state.
    If the state doesn’t repeat infinitely often, it is not the same state
    and does halt.


    It took me two years to come up with these words please make
    sure that you totally understand each one of them.

    <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
        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.
    </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>



    And you perfectly trapped yourself as it is well known that to Professor Sipser, like any sane person working in the field, the definition of a
    "Correct Simulation" means (unless psecifically ammended, which you
    forgot to do) a simulation that FULLY reproduces the behavior that the
    machine the input represents does when it is run.

    Since D(D) Halts when run (since your H is defined to abort its
    simulation and return non-halting, in your mind correctly) then any
    "Correct Simulation" of the input will show this too, so it is
    IMPOSSIBLE that THIS H's simulation be correct and show it to never stop running, as that is by definition not a correct simulation, and it is
    also IMPOSSIBLE for H to correctly determine that ANY "Correct
    Simulation" of this input would never stop running as it does stop running.

    So, you laid the perfect trap for yourself giving him a softball to hit
    out of the park, giving you a true answer that you just don't
    understand, because you are so convinced that you are allowed to change
    the fundamental meaning of words.

    In simpler words, you logic is based on your claiming the right to LIE
    by redefining the words that others use.

    Perhaps a lot of this is just due to your utter ignorance and stupidity
    because you never bothered to learn the terminology of the field, but
    tried to deduce it with your "zeroth order principles" (they are not
    based first principles, as that requires you to first learn those first principles) from which you have made up your (largely incorrect)
    definitions of the terms. But it isn't just ignorance, as ignorance will
    try to learn when corrected, but you just stick your heels in the shit
    you produced and ignore the truth, thus, making you into a pathological
    liar, who with a reckless disregard for the truth, tries to spread your
    false ideas as if they had some foundation other than the POOP that
    fills your mind.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to joes on Fri Jul 5 10:07:32 2024
    On 2024-07-04 10:20:55 +0000, joes said:

    Am Wed, 03 Jul 2024 10:51:40 -0500 schrieb olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 16:29 schreef olcott:
    On 7/3/2024 9:16 AM, joes wrote:
    Am Wed, 03 Jul 2024 08:27:40 -0500 schrieb olcott:
    On 7/3/2024 6:44 AM, Richard Damon wrote:
    On 7/2/24 11:43 PM, olcott wrote:
    On 7/2/2024 10:23 PM, Richard Damon wrote:
    On 7/2/24 11:07 PM, olcott wrote:
    On 7/2/2024 9:35 PM, Richard Damon wrote:
    On 7/2/24 10:03 PM, olcott wrote:
    On 7/2/2024 8:51 PM, Richard Damon wrote:
    On 7/2/24 9:32 PM, olcott wrote:
    On 7/2/2024 8:25 PM, Richard Damon wrote:
    On 7/2/24 9:18 PM, olcott wrote:

    And the only CORRECT EMULATION of that program is to infiniately >>>>>>>>> loop in the emulation.
    Not for a freaking termination analyzer nitwit.
    Why do they get to lie?
    Open question.

    Nothing says that you can't make a halt decider work with partial >>>>>>>>> emulation for SOME inputs. But the halt Decider just isn't itself >>>>>>>>> a fully correct emulator.
    You keep stupidly saying that less than an infinite emulation is >>>>>>>> an incorrect emulation. Why do you keep stupidly doing that?
    Because it is. Partial emulations only show partial truth, and
    truth is the whole truth and nothing but the truth.
    BEHAVIOR needs the FULL description of what happens.

    Why do you keep lying about this?
    As soon as HHH has seen a repeating state it has seen enough.
    If the state is actually the same. But the simulated HHH sets a flag >>>>> or something to keep track if it is itself simulating a repetition.
    <- Which it therefore isn’t.

    *This is the repeating state*
    But not an *infinitely* repeating state.

    The criteria that I spent two years writing and the best selling author
    of theory of computation textbooks agrees with says nothing about
    *infinitely* repeating state.
    If the state doesn’t repeat infinitely often, it is not the same state
    and does halt.

    That "halt" does not follow. A Turing machine can execute forever without repeating its state.

    --
    Mikko

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