1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: Olcott seems to be willfully ignorant --- AKA is Fred a Liar ?

    From Fred. Zwarts@21:1/5 to All on Wed Jul 3 18:04:18 2024
    Op 03.jul.2024 om 17:51 schreef 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:

    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.

    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.

    Irrelevant, because that is about a correct simulation. Your simulation
    is incorrect, so Sipser does not apply here.
    Sorry, you wasted two years, where a beginner could have corrected you.


    If you would quit trying to form rebuttals by deceptively
    twisting my words you would have to agree that I am correct.

    No, you are twisting Sipser's words, which were in the context of a
    correct simulation. Your simulation is not correct.


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


    You are running in circles. So, you will not proceed. Think a little bit
    about it.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Alan Mackenzie@21:1/5 to olcott on Wed Jul 3 16:18:02 2024
    olcott <[email protected]> wrote:
    On 7/3/2024 11:04 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 17:51 schreef olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:

    [ .... ]

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

    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.

    Irrelevant, because that is about a correct simulation. Your simulation
    is incorrect, so Sipser does not apply here.

    OK you are a liar then.

    I don't think so. There is only one liar on this newsgroup, and it's not
    Fred.

    --
    Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
    hits a target no one else can see." Arthur Schopenhauer

    --
    Alan Mackenzie (Nuremberg, Germany).

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Wed Jul 3 19:58:18 2024
    Op 03.jul.2024 om 18:09 schreef olcott:
    On 7/3/2024 11:04 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 17:51 schreef 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:

    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.

    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.

    Irrelevant, because that is about a correct simulation. Your
    simulation is incorrect, so Sipser does not apply here.

    OK you are a liar then.


    Irrelevant ad hominem attack ignored. It shows that your argumentation
    failed. I proved that HHH cannot possibly correctly simulate itself.
    You are unable to show an error in the proof.

    --
    Paradoxes in the relation between Creator and creature. <http://www.wirholt.nl/English>.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Wed Jul 3 20:01:14 2024
    Op 03.jul.2024 om 18:24 schreef olcott:
    On 7/3/2024 11:18 AM, Alan Mackenzie wrote:
    olcott <[email protected]> wrote:
    On 7/3/2024 11:04 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 17:51 schreef olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:

    [ .... ]

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

    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.

    Irrelevant, because that is about a correct simulation. Your simulation >>>> is incorrect, so Sipser does not apply here.

    OK you are a liar then.

    I don't think so.  There is only one liar on this newsgroup, and it's not >> Fred.


    *A liar is anyone that denies this*

    Another display of lack of correct reasoning.


    _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 this process until the emulated DDD is aborted.

    I proved that HHH cannot possibly correctly simulate itself.
    You are unable to show the error in the proof.
    If you then repeat 'correctly', who is ignoring the truth?

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Wed Jul 3 20:20:13 2024
    Op 03.jul.2024 om 20:04 schreef olcott:
    On 7/3/2024 1:01 PM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 18:24 schreef olcott:
    On 7/3/2024 11:18 AM, Alan Mackenzie wrote:
    olcott <[email protected]> wrote:
    On 7/3/2024 11:04 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 17:51 schreef olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:

    [ .... ]

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

    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.

    Irrelevant, because that is about a correct simulation. Your
    simulation
    is incorrect, so Sipser does not apply here.

    OK you are a liar then.

    I don't think so.  There is only one liar on this newsgroup, and
    it's not
    Fred.


    *A liar is anyone that denies this*

    Another display of lack of correct reasoning.


    _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 this process until the emulated DDD is aborted.

    I proved that HHH cannot possibly correctly simulate itself.

    Liar
    https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

    Your trace confirms my proof.
    The full trace shows that the simulation of the simulator is unable to
    reach the simulation of the 'ret' of the simulated simulator.
    This is further evidence that the ad hominem attack is only used to hide
    a lack of argumentation.


    You are unable to show the error in the proof.
    If you then repeat 'correctly', who is ignoring the truth?



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Wed Jul 3 20:41:51 2024
    Op 03.jul.2024 om 20:21 schreef olcott:
    On 7/3/2024 1:20 PM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 20:04 schreef olcott:
    On 7/3/2024 1:01 PM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 18:24 schreef olcott:
    On 7/3/2024 11:18 AM, Alan Mackenzie wrote:
    olcott <[email protected]> wrote:
    On 7/3/2024 11:04 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 17:51 schreef olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:

    [ .... ]

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

    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.

    Irrelevant, because that is about a correct simulation. Your
    simulation
    is incorrect, so Sipser does not apply here.

    OK you are a liar then.

    I don't think so.  There is only one liar on this newsgroup, and
    it's not
    Fred.


    *A liar is anyone that denies this*

    Another display of lack of correct reasoning.


    _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 this process until the emulated DDD is aborted.

    I proved that HHH cannot possibly correctly simulate itself.

    Liar
    https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

    Your trace confirms my proof.
    The full trace shows that the simulation of the simulator is unable to
    reach the simulation of the 'ret' of the simulated simulator.

    Liar

    Lack of argumentation, so try an ad hominem attack. Ignored.


    This is further evidence that the ad hominem attack is only used to
    hide a lack of argumentation.


    You are unable to show the error in the proof.
    If you then repeat 'correctly', who is ignoring the truth?




    --- 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:41 2024
    On 7/3/24 12:24 PM, olcott wrote:
    On 7/3/2024 11:18 AM, Alan Mackenzie wrote:
    olcott <[email protected]> wrote:
    On 7/3/2024 11:04 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 17:51 schreef olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:

    [ .... ]

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

    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.

    Irrelevant, because that is about a correct simulation. Your simulation >>>> is incorrect, so Sipser does not apply here.

    OK you are a liar then.

    I don't think so.  There is only one liar on this newsgroup, and it's not >> Fred.


    *A liar is anyone that denies this*

    _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 this process until the emulated DDD is aborted.

    Except that is a LIE, as the simulation by that HHH never gets back to
    the beginning of DDD, but stays inside of HHH.

    At best, HHH can decide that HHH(DDD) is non-halting, and then prove
    itself wrong by halting.


    --
    Copyright 2024 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 Mikko@21:1/5 to olcott on Thu Jul 4 09:21:34 2024
    On 2024-07-03 18:23:18 +0000, olcott said:

    On 7/3/2024 1:20 PM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 20:04 schreef olcott:
    On 7/3/2024 1:01 PM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 18:24 schreef olcott:
    On 7/3/2024 11:18 AM, Alan Mackenzie wrote:
    olcott <[email protected]> wrote:
    On 7/3/2024 11:04 AM, Fred. Zwarts wrote:
    Op 03.jul.2024 om 17:51 schreef olcott:
    On 7/3/2024 10:40 AM, Fred. Zwarts wrote:

    [ .... ]

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

    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.

    Irrelevant, because that is about a correct simulation. Your simulation
    is incorrect, so Sipser does not apply here.

    OK you are a liar then.

    I don't think so.  There is only one liar on this newsgroup, and it's not
    Fred.


    *A liar is anyone that denies this*

    Another display of lack of correct reasoning.


    _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 this process until the emulated DDD is aborted.

    I proved that HHH cannot possibly correctly simulate itself.

    Liar
    https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

    Your trace confirms my proof.
    The full trace shows that the simulation of the simulator is unable to
    reach the simulation of the 'ret' of the simulated simulator.

    I was too hasty when I called you a Liar on this.

    More generally, you are too hasty to call anyone a liar on anyting.

    --
    Mikko

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