1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: Flat out dishonest or totally ignorant? --- Olcott seems to be will

    From Richard Damon@21:1/5 to olcott on Wed Jul 3 07:44:29 2024
    XPost: sci.logic

    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:

    Professor Sipser probably does understand the x86 language.
    Shared-memory implementation of the Karp-Sipser
    kernelization process
    https://inria.hal.science/hal-03404798/file/hipc2021.pdf


    And the x86 language says the same thing,

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

    Sorry, you are just too stupid to understand.

    You continue to assume that you can simply disagree
    with the x86 language. My memory was refreshed that
    called you stupid would be a sin according to Christ.
    I really want to do the best I can to repent.


    But I am NOT disagreeing with the x86 language.

    Can you point out what fact of it I am disagreing about it?


    You keep trying to get away with saying that the simulation is
    incorrect when the semantics of the x86 language conclusively
    proves that it is correct.

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

    void Infinite_Loop()
    {
       HERE: goto HERE;
    }

    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?


    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.

    There is a difference between taking something from a store, and taking something but paying for it on the way out.

    But, apparently to you those are the same thing,


    Now, Emulating something is different than looking at something, perhaps
    doing a bit of emulation, and coming up with a description of what it
    does (like a decider does). The key is a proper description of what the
    thing does would be what that "infinite emulation" of it did, not just
    the parts that the decider saw, unless it specifically limits its claims
    and admits it isn't giving a full description.

    For a witness to conclude that a person stole an item from the store
    because he saw him take the item, and then later left, would be
    committing perjury if they neglected to mention that there was a period
    when they didn't observe the person and they could have paid for it.

    In the same way, for the decider to say that the input DOES NOT HALT,
    when all the decider actually knows is that it didn't halt during its
    partial emulation of it, is just being a LIAR. (and arguing about a
    DIFFERENT input with a DIFFERENT decider is also just a LIE).

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Wed Jul 3 19:18:55 2024
    XPost: sci.logic

    On 7/3/24 9:22 AM, olcott wrote:
    On 7/3/2024 3:33 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 05:07 schreef olcott:
    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:

    Professor Sipser probably does understand the x86 language.
    Shared-memory implementation of the Karp-Sipser
    kernelization process
    https://inria.hal.science/hal-03404798/file/hipc2021.pdf


    And the x86 language says the same thing,

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

    Sorry, you are just too stupid to understand.

    You continue to assume that you can simply disagree
    with the x86 language. My memory was refreshed that
    called you stupid would be a sin according to Christ.
    I really want to do the best I can to repent.


    But I am NOT disagreeing with the x86 language.

    Can you point out what fact of it I am disagreing about it?


    You keep trying to get away with saying that the simulation is
    incorrect when the semantics of the x86 language conclusively
    proves that it is correct.

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

    void Infinite_Loop()
    {
       HERE: goto HERE;
    }

    Why do you say such ridiculously stupid things that you are are false?


    Your Infinite_Loop does not apply. For a two cycle recursive simulation


    This says nothing about two cycles nitwit.

    _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]

    DDD is correctly emulated by HHH which calls an
    emulated HHH(DDD) to repeat the process until aborted.



    And when aborted, DDD will then return, so HHH can not say that its
    input is non-halting.

    Only that HHH can not POOP DDD. (where POOPing is assuemed to be the
    horse shit subjective criteria that HHH can not emulate the input to its conclusion.)

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Thu Jul 4 09:15:59 2024
    On 2024-07-03 13:27:40 +0000, olcott said:

    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:

    Professor Sipser probably does understand the x86 language. >>>>>>>>>>> Shared-memory implementation of the Karp-Sipser
    kernelization process
    https://inria.hal.science/hal-03404798/file/hipc2021.pdf >>>>>>>>>>>

    And the x86 language says the same thing,

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

    Sorry, you are just too stupid to understand.

    You continue to assume that you can simply disagree
    with the x86 language. My memory was refreshed that
    called you stupid would be a sin according to Christ.
    I really want to do the best I can to repent.


    But I am NOT disagreeing with the x86 language.

    Can you point out what fact of it I am disagreing about it?


    You keep trying to get away with saying that the simulation is
    incorrect when the semantics of the x86 language conclusively
    proves that it is correct.

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

    void Infinite_Loop()
    {
       HERE: goto HERE;
    }

    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?


    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.

    No, it has not. When it sees a repeating state first time there is no way
    to know that it is a repeating state. That can be determined only when
    the same state is seen again and then only if the state as seen the first
    time is still fully remembered or reconstructed.

    You have not proven that every detail of the state is inculded in determination.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu Jul 4 11:24:38 2024
    On 7/4/24 8:37 AM, olcott wrote:
    On 7/4/2024 1:15 AM, Mikko wrote:
    On 2024-07-03 13:27:40 +0000, olcott said:

    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:

    Professor Sipser probably does understand the x86 language. >>>>>>>>>>>>> Shared-memory implementation of the Karp-Sipser
    kernelization process
    https://inria.hal.science/hal-03404798/file/hipc2021.pdf >>>>>>>>>>>>>

    And the x86 language says the same thing,

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

    Sorry, you are just too stupid to understand.

    You continue to assume that you can simply disagree
    with the x86 language. My memory was refreshed that
    called you stupid would be a sin according to Christ.
    I really want to do the best I can to repent.


    But I am NOT disagreeing with the x86 language.

    Can you point out what fact of it I am disagreing about it? >>>>>>>>>>

    You keep trying to get away with saying that the simulation is >>>>>>>>> incorrect when the semantics of the x86 language conclusively >>>>>>>>> proves that it is correct.

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

    void Infinite_Loop()
    {
       HERE: goto HERE;
    }

    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?


    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.

    No, it has not. When it sees a repeating state first time there is no way
    to know that it is a repeating state.
    You are incompetent

    No, YOU are incompetent, and have admitted such.

    Remember, you claimed there was a diagonalization proof that showed
    Godel was wrong, and then you claimed that such proofs are nonsense, so
    you admitted that you believe in nonsense proofs as a reason you are
    "correct".


    That can be determined only when
    the same state is seen again and then only if the state as seen the first
    time is still fully remembered or reconstructed.

    You have not proven that every detail of the state is inculded in
    determination.



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to olcott on Fri Jul 5 10:16:16 2024
    On 2024-07-04 12:37:19 +0000, olcott said:

    On 7/4/2024 1:15 AM, Mikko wrote:
    On 2024-07-03 13:27:40 +0000, olcott said:

    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:

    Professor Sipser probably does understand the x86 language. >>>>>>>>>>>>> Shared-memory implementation of the Karp-Sipser
    kernelization process
    https://inria.hal.science/hal-03404798/file/hipc2021.pdf >>>>>>>>>>>>>

    And the x86 language says the same thing,

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

    Sorry, you are just too stupid to understand.

    You continue to assume that you can simply disagree
    with the x86 language. My memory was refreshed that
    called you stupid would be a sin according to Christ.
    I really want to do the best I can to repent.


    But I am NOT disagreeing with the x86 language.

    Can you point out what fact of it I am disagreing about it? >>>>>>>>>>

    You keep trying to get away with saying that the simulation is >>>>>>>>> incorrect when the semantics of the x86 language conclusively >>>>>>>>> proves that it is correct.

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

    void Infinite_Loop()
    {
       HERE: goto HERE;
    }

    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?


    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.

    No, it has not. When it sees a repeating state first time there is no way
    to know that it is a repeating state.

    You are incompetent

    I'm not competing nor planning to compete if that is what you mean.
    If you mean that I can't compete that is ulikely to be tested.
    I have competed and won but that was long ago.

    Anyway, as you have no counter argument my comment stands as written.

    --
    Mikko

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to Mikko on Fri Jul 5 11:06:49 2024
    On 7/5/24 3:16 AM, Mikko wrote:
    On 2024-07-04 12:37:19 +0000, olcott said:

    On 7/4/2024 1:15 AM, Mikko wrote:
    On 2024-07-03 13:27:40 +0000, olcott said:

    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:

    Professor Sipser probably does understand the x86 language. >>>>>>>>>>>>>> Shared-memory implementation of the Karp-Sipser
    kernelization process
    https://inria.hal.science/hal-03404798/file/hipc2021.pdf >>>>>>>>>>>>>>

    And the x86 language says the same thing,

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

    Sorry, you are just too stupid to understand.

    You continue to assume that you can simply disagree
    with the x86 language. My memory was refreshed that
    called you stupid would be a sin according to Christ.
    I really want to do the best I can to repent.


    But I am NOT disagreeing with the x86 language.

    Can you point out what fact of it I am disagreing about it? >>>>>>>>>>>

    You keep trying to get away with saying that the simulation is >>>>>>>>>> incorrect when the semantics of the x86 language conclusively >>>>>>>>>> proves that it is correct.

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

    void Infinite_Loop()
    {
       HERE: goto HERE;
    }

    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?


    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.

    No, it has not. When it sees a repeating state first time there is no
    way
    to know that it is a repeating state.

    You are incompetent

    I'm not competing nor planning to compete if that is what you mean.
    If you mean that I can't compete that is ulikely to be tested.
    I have competed and won but that was long ago.

    Anyway, as you have no counter argument my comment stands as written.


    I guess that just went above your head, as you read the wrong word.


    Incompetent:
    not having or showing the necessary skills to do something successfully

    You ARE incompetent at logic, and Computation Theory (and a lot of other
    things too).

    Non-Halting Turing Machines exist that NEVER repeat their state.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mikko@21:1/5 to Richard Damon on Sat Jul 6 09:20:03 2024
    On 2024-07-05 15:06:49 +0000, Richard Damon said:

    On 7/5/24 3:16 AM, Mikko wrote:
    On 2024-07-04 12:37:19 +0000, olcott said:

    On 7/4/2024 1:15 AM, Mikko wrote:
    On 2024-07-03 13:27:40 +0000, olcott said:

    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:

    Professor Sipser probably does understand the x86 language. >>>>>>>>>>>>>>> Shared-memory implementation of the Karp-Sipser
    kernelization process
    https://inria.hal.science/hal-03404798/file/hipc2021.pdf >>>>>>>>>>>>>>>

    And the x86 language says the same thing,

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

    Sorry, you are just too stupid to understand.

    You continue to assume that you can simply disagree
    with the x86 language. My memory was refreshed that
    called you stupid would be a sin according to Christ. >>>>>>>>>>>>> I really want to do the best I can to repent.


    But I am NOT disagreeing with the x86 language.

    Can you point out what fact of it I am disagreing about it? >>>>>>>>>>>>

    You keep trying to get away with saying that the simulation is >>>>>>>>>>> incorrect when the semantics of the x86 language conclusively >>>>>>>>>>> proves that it is correct.

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

    void Infinite_Loop()
    {
       HERE: goto HERE;
    }

    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?


    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.

    No, it has not. When it sees a repeating state first time there is no way >>>> to know that it is a repeating state.

    You are incompetent

    I'm not competing nor planning to compete if that is what you mean.
    If you mean that I can't compete that is ulikely to be tested.
    I have competed and won but that was long ago.

    Anyway, as you have no counter argument my comment stands as written.

    I guess that just went above your head, as you read the wrong word.

    No, I just intentilnally misinterpreted the word.

    Incompetent:
    not having or showing the necessary skills to do something successfully

    You ARE incompetent at logic, and Computation Theory (and a lot of
    other things too).

    That I don't alwasy show much skills does not mean that I don't have.

    Non-Halting Turing Machines exist that NEVER repeat their state.

    Take that as a hint that I do know at least something about computation
    theory.

    --
    Mikko

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