• DDD correctly simulated by HHH can't possibly reach its own "return" s

    From olcott@3:633/280.2 to All on Sat Jun 28 05:36:33 2025
    Subject: DDD correctly simulated by HHH can't possibly reach its own "return"
    statement --- Liars on comp.theory

    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

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


    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From Mike Terry@3:633/280.2 to All on Sat Jun 28 10:14:29 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 27/06/2025 20:36, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

    Well, people here use the term "simulation" in a number of ways, right? Like I've pointed out to
    you on several occasions. Maybe you should consider a simple misunderstanding over terminology
    before assuming bad intentions.

    So what does Alan mean by "the simulation by HHH is incorrect", exactly? (And why do you think it
    is incorrect?)

    That is a question for PO, rather than Alan, since it is PO who claims Alan is lying...

    Mike.


    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From wij@3:633/280.2 to All on Sat Jun 28 17:43:52 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.
    (Don't bother answering this question. We know what you would say.)

    I have included proof that the people on comp.theory
    lied about this at the bottom.
    =20
    typedef void (*ptr)();
    int HHH(ptr P);
    =20
    void DDD()
    {
    =C2=A0=C2=A0 HHH(DDD);
    =C2=A0=C2=A0 return;
    }
    =20
    int main()
    {
    =C2=A0=C2=A0 HHH(DDD);
    =C2=A0=C2=A0 DDD();
    }
    =20
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern.=C2=A0

    HHH(DDD) will run in infinite loop, which conforms to Halting Problem proof=
    ..

    When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    This looks like a problem specification, but you said "Halting Problem" is incorrect. Peter Olcott's Own Problem is never clear.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    =C2=A0> In comp.theory olcott <polcott333@gmail.com
    =C2=A0> wrote:
    =C2=A0>
    =C2=A0>> I know that DDD .... simulated by HHH cannot
    =C2=A0>> possibly reach its own simulated "return" statement
    =C2=A0>> final halt state because the execution trace
    =C2=A0>> conclusively proves this.
    =C2=A0>
    =C2=A0> Everybody else knows this, too, and nobody has
    =C2=A0> said otherwise. *The conclusion is that the*
    =C2=A0> *simulation by HHH is incorrect*
    =C2=A0>
    =20
    *That last sentence is an intentional falsehood*

    Actually, it is olcott who lies. The evidence keeps accumulating for years. Because the evidences (olcott's posts) show that olcott knows what the HP s= ays,
    he deliberately and very stubbornly wants to conclude differently by trying= =20
    every possible way (for years, and think he will hit the target).

    Because olcott is so Computer-Science-Stupid (He doesn't understand the=20 meaning of logic-IF. He can't write a TM that computes the length of its=C2= =A0
    input. The proof of a piece of C program is its compiled assembly,...)=C2=
    =A0
    to lie?

    I prefer to say olcott deliberately lies, because he does experiment with a real program (where he tried various ways to make it interpret-able as what=
    he
    claims) he knows what happens and makes false reports (not what has actuall=
    y
    happened, like this post, he knows what is inappropriate and not good to hi=
    s
    claim) to 'prove' his claim even thought there is no logical connection=C2=
    =A0
    (always like to saying "a white dog", while pointing to a black cat).=C2=A0
    It is still so, hardly to see olcott posts real thing instead of confusing equivocal arguments.


    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 01:00:52 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/27/2025 7:14 PM, Mike Terry wrote:
    On 27/06/2025 20:36, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

    Well, people here use the term "simulation" in a number of ways, right?

    *There is only one correct way*

    void DDD()
    {
    HHH(DDD);
    return;
    }

    The correct simulation of DDD by HHH means that HHH simulates
    DDD and then emulates itself simulating DDD a number of times
    according to the semantics of C.

    Everyone here knows that DDD correctly simulated by HHH
    cannot possibly reach its own simulated "return" statement.
    Most everyone on comp.theory lies about this.

    Like I've pointed out to you on several occasions. Maybe you should consider a simple misunderstanding over terminology before assuming bad intentions.


    After three years on this same point a simple misunderstanding
    has been ruled out.

    So what does Alan mean by "the simulation by HHH is incorrect",
    exactly? (And why do you think it is incorrect?)


    He is simply lying. Most of the reviews of my work are
    counter-factual dogmatic assertions utterly bereft of
    any supporting reasoning.

    That is a question for PO, rather than Alan, since it is PO who claims
    Alan is lying...

    Mike.



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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 01:04:45 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.





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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From dbush@3:633/280.2 to All on Sun Jun 29 01:14:24 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped the below
    in his reply but YOU:

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern.

    HHH(DDD) will run in infinite loop, which conforms to Halting Problem proof. >>
    When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    And here is the part that you dishonestly said was erased when in fact
    it was not.

    This proves that it is YOU who are lying and will say anything to push
    your agenda.


    This looks like a problem specification, but you said "Halting Problem" is >> incorrect. Peter Olcott's Own Problem is never clear.


    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 01:17:01 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped the below
    in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.

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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From dbush@3:633/280.2 to All on Sun Jun 29 01:21:04 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped the below
    in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove you wrong.

    Your dishonesty knows no bounds. And as you yourself self:

    On 5/25/2025 3:04 PM, olcott wrote:
    You Are the epitome of bad faith and dishonesty.
    This may cost you your actual soul: Revelations 21:8.


    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern.

    HHH(DDD) will run in infinite loop, which conforms to Halting Problem >>>> proof.

    When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    And here is the part that you dishonestly said was erased when in fact
    it was not.

    This proves that it is YOU who are lying and will say anything to push
    your agenda.


    Your failure to reply to the above, and in fact your dishonest erasing
    of it constitutes your admission of lying to push your agenda.


    This looks like a problem specification, but you said "Halting
    Problem" is
    incorrect. Peter Olcott's Own Problem is never clear.

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 01:30:33 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped the
    below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove you wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.

    Your mere rhetoric to the contrary does not actually change
    these verified facts. Are you able to stick with correct
    reasoning or is mere rhetoric all that you have?

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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From dbush@3:633/280.2 to All on Sun Jun 29 01:39:49 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 11:30 AM, olcott wrote:
    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped the
    below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove you wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.


    No, you didn't give a definition of HHH, just gave a vauge incomplete description of what you think it does.

    What is is a verified fact that you openly and blatantly lied about wij erasing your description when it was in fact you yourself that did it.

    All you are doing is showing the depths of your dishonesty.



    Your mere rhetoric to the contrary does not actually change
    these verified facts. Are you able to stick with correct
    reasoning or is mere rhetoric all that you have?

    Your dishonesty knows no bounds. And as you yourself self:

    On 5/25/2025 3:04 PM, olcott wrote:
    You Are the epitome of bad faith and dishonesty.
    This may cost you your actual soul: Revelations 21:8.


    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern.

    HHH(DDD) will run in infinite loop, which conforms to Halting
    Problem proof.

    When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    And here is the part that you dishonestly said was erased when in
    fact it was not.

    This proves that it is YOU who are lying and will say anything to
    push your agenda.


    Your failure to reply to the above, and in fact your dishonest erasing
    of it constitutes your admission of lying to push your agenda.


    This looks like a problem specification, but you said "Halting
    Problem" is
    incorrect. Peter Olcott's Own Problem is never clear.


    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 01:46:15 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 10:39 AM, dbush wrote:
    On 6/28/2025 11:30 AM, olcott wrote:
    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped the
    below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove you
    wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.


    No, you didn't give a definition of HHH, just gave a vauge incomplete description of what you think it does.


    It completely defines the generic notion of a simulating
    termination analyzer and

    It specifies every detail about HHH that is required
    to correctly determine whether or not DDD correctly
    simulated by HHH can possibly reach its own simulated
    "return" statement final halt state.

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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From dbush@3:633/280.2 to All on Sun Jun 29 01:52:57 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 11:46 AM, olcott wrote:
    On 6/28/2025 10:39 AM, dbush wrote:
    On 6/28/2025 11:30 AM, olcott wrote:
    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped the
    below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove you
    wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.


    No, you didn't give a definition of HHH, just gave a vauge incomplete
    description of what you think it does.


    It completely defines the generic notion of a simulating
    termination analyzer and

    It specifies every detail about HHH that is required
    to correctly determine whether or not DDD correctly
    simulated by HHH can possibly reach its own simulated
    "return" statement final halt state.


    But why would you say that when you've admitted on the record (see
    below) that DDD is not in fact correctly simulated by HHH?


    On 5/5/2025 8:24 AM, dbush wrote:
    On 5/4/2025 11:03 PM, dbush wrote:
    On 5/4/2025 10:05 PM, olcott wrote:
    On 5/4/2025 7:23 PM, Richard Damon wrote:
    But HHH doesn't correct emulated DD by those rules, as those rules
    do not allow HHH to stop its emulation,

    Sure they do you freaking moron...

    Then show where in the Intel instruction manual that the execution of
    any instruction other than a HLT is allowed to stop instead of
    executing the next instruction.

    Failure to do so in your next reply, or within one hour of your next
    post on this newsgroup, will be taken as you official on-the-record
    admission that there is no such allowance and that HHH does NOT
    correctly simulate DD.

    Let the record show that Peter Olcott made the following post in this newsgroup after the above message:

    On 5/4/2025 11:04 PM, olcott wrote:
    D *WOULD NEVER STOP RUNNING UNLESS*
    indicates that professor Sipser was agreeing
    to hypotheticals AS *NOT CHANGING THE INPUT*

    You are taking
    *WOULD NEVER STOP RUNNING UNLESS*
    to mean *NEVER STOPS RUNNING* that is incorrect.

    And has made no attempt after over 9 hours to show where in the Intel instruction manual that execution is allowed to stop after any
    instruction other than HLT.

    Therefore, as per the above criteria:

    LET THE RECORD SHOW

    That Peter Olcott

    Has *officially* admitted

    That DD is NOT correctly simulated by HHH


    What is is a verified fact that you openly and blatantly lied about wij
    erasing your description when it was in fact you yourself that did it.


    That you made no attempt to refute the above and in fact dishonestly
    erased it constitutes your admission that you were lying and will in
    fact lie about the simplest of things that can be easily verified as false.

    This demonstrates to all that nothing you say can be taken seriously.


    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 02:03:31 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 10:52 AM, dbush wrote:
    On 6/28/2025 11:46 AM, olcott wrote:
    On 6/28/2025 10:39 AM, dbush wrote:
    On 6/28/2025 11:30 AM, olcott wrote:
    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped the >>>>>>> below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove you
    wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.


    No, you didn't give a definition of HHH, just gave a vauge incomplete
    description of what you think it does.


    It completely defines the generic notion of a simulating
    termination analyzer and

    It specifies every detail about HHH that is required
    to correctly determine whether or not DDD correctly
    simulated by HHH can possibly reach its own simulated
    "return" statement final halt state.


    But why would you say that when you've admitted on the record (see
    below) that DDD is not in fact correctly simulated by HHH?


    *I am not going to tolerate any misdirection to any other points*

    void DDD()
    {
    HHH(DDD);
    return;
    }

    The only point relevant to this forum is that DDD correctly
    simulated by HHH cannot possibly reach its own simulated
    "return" statement final halt state.

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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From Mike Terry@3:633/280.2 to All on Sun Jun 29 02:22:48 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 28/06/2025 16:00, olcott wrote:
    On 6/27/2025 7:14 PM, Mike Terry wrote:
    On 27/06/2025 20:36, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

    Well, people here use the term "simulation" in a number of ways, right?

    *There is only one correct way*

    That's patently rubbish.

    This is one of your major cognitive mistakes - believing that the squiggles which make up words have
    an absolute meaning independently of the people using them to (hopefully) communicate.


    void DDD()
    {
    HHH(DDD);
    return;
    }

    The correct simulation of DDD by HHH means that HHH simulates
    DDD and then emulates itself simulating DDD a number of times
    according to the semantics of C.

    "a number of times"???

    a) Does a correct simulation need to simulate until its target computation terminates?

    b) Does a simulation need to also correctly decide halting for its target computation?

    [My personal answers would be "no" and "no" - I would consider what others may insist on calling a
    partial simulation to a correct example of "simulation" (but of course incomplete), provided the
    steps of the simulation are correctly calculated; and I consider deciding the halt status to be the
    job of a halt "decider" rather than a simulator [of course a halt decider may /utilise/ simulation
    as a technique in reaching its decision]. Other ways of looking at this are equally valid and we
    need to understand each other's positions.]


    Everyone here knows that DDD correctly simulated by HHH
    cannot possibly reach its own simulated "return" statement.

    That's what Alan said above. Read his words: "Everybody else knows this, too, and nobody has said
    otherwise." You need to read what people write and keep track of the conversation...

    Most everyone on comp.theory lies about this.

    Well, not Alan (whom you accused), or me, or Richard or Mikko or Fred (I expect I could include
    others but can't be bothered to research the question).

    So who lies about it exactly, and you had better provide a (recent) link to them lying! Or just
    admit you haven't a clue what people are actually saying to you...


    Like I've pointed out to you on several occasions. Maybe you should consider a simple
    misunderstanding over terminology before assuming bad intentions.


    After three years on this same point a simple misunderstanding
    has been ruled out.

    For a "normal" correspondant perhaps, but you forget your own disabilities - you are incapable of
    understanding what people say to you, including whether they are agreeing with you (in strictly
    limited parts) or not.


    So what does Alan mean by "the simulation by HHH is incorrect", exactly? (And why do you think it
    is incorrect?)


    He is simply lying. Most of the reviews of my work are
    counter-factual dogmatic assertions utterly bereft of
    any supporting reasoning.

    Lol, you haven't even answered the question of what you think Alan meant by his statement, or why
    that is a lie. So how can you be sure he is lying? All you've talked about above is the bit Alan
    explicitly said he /agreed/ with.


    Mike.


    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 02:47:38 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 11:22 AM, Mike Terry wrote:
    On 28/06/2025 16:00, olcott wrote:
    On 6/27/2025 7:14 PM, Mike Terry wrote:
    On 27/06/2025 20:36, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

    Well, people here use the term "simulation" in a number of ways, right?

    *There is only one correct way*

    That's patently rubbish.

    This is one of your major cognitive mistakes - believing that the
    squiggles which make up words have an absolute meaning independently of
    the people using them to (hopefully) communicate.


    void DDD()
    {
    HHH(DDD);
    return;
    }

    The correct simulation of DDD by HHH means that HHH simulates
    DDD and then emulates itself simulating DDD a number of times
    according to the semantics of C.

    "a number of times"???


    Do you know what a number is?
    In this case I am referring to every non-negative integer.

    a) Does a correct simulation need to simulate until its target
    computation terminates?


    There is no target computation here we only have the
    behavior that the input to HHH(DDD) specifies.

    Anyone that knows what recursion is should be able to
    see that DDD correctly simulated by HHH never reaches
    its own simulated "return" instruction final halt state.

    b) Does a simulation need to also correctly decide halting for its
    target computation?


    There is no target computation here we only have the
    behavior that the input to HHH(DDD) specifies.

    [My personal answers would be "no" and "no" - I would consider what
    others may insist on calling a partial simulation to a correct example
    of "simulation" (but of course incomplete), provided the steps of the simulation are correctly calculated; and I consider deciding the halt
    status to be the job of a halt "decider" rather than a simulator [of
    course a halt decider may /utilise/ simulation as a technique in
    reaching its decision]. Other ways of looking at this are equally valid
    and we need to understand each other's positions.]


    Everyone here knows that DDD correctly simulated by HHH
    cannot possibly reach its own simulated "return" statement.

    That's what Alan said above. Read his words: "Everybody else knows
    this, too,

    Alan dishonesty changed the words of my quote erasing
    the word "correctly".

    and nobody has said otherwise." You need to read what people
    write and keep track of the conversation...


    I didn't notice that Alan dishonestly changed the words
    of my quote at first either. That is why I check these
    things many times before I submit my reply.

    Most everyone on comp.theory lies about this.

    Well, not Alan (whom you accused), or me, or Richard or Mikko or Fred
    (I expect I could include others but can't be bothered to research the question).

    So who lies about it exactly, and you had better provide a (recent) link
    to them lying! Or just admit you haven't a clue what people are
    actually saying to you...


    *Everyone besides Keith has denied this verified fact*
    DDD correctly simulated by HHH cannot possibly reach
    its own simulated "return" statement final halt state.


    Like I've pointed out to you on several occasions. Maybe you should
    consider a simple misunderstanding over terminology before assuming
    bad intentions.


    After three years on this same point a simple misunderstanding
    has been ruled out.

    For a "normal" correspondant perhaps, but you forget your own
    disabilities - you are incapable of understanding what people say to
    you, including whether they are agreeing with you (in strictly limited parts) or not.


    That is counter-factual.
    When I reject their counter-factual statements
    this is not any lack of understanding on my part.


    So what does Alan mean by "the simulation by HHH is incorrect",
    exactly? (And why do you think it is incorrect?)


    He is simply lying. Most of the reviews of my work are
    counter-factual dogmatic assertions utterly bereft of
    any supporting reasoning.

    Lol, you haven't even answered the question of what you think Alan meant
    by his statement,

    It does not matter how he made a counter-factual statement
    it only matters that it was counter-factual.

    That he seems to think that he can get away with disagreeing
    with the semantics of the C programming language doesn't seem
    like it could reasonably be construed as any honest mistake.

    or why that is a lie. So how can you be sure he is
    lying? All you've talked about above is the bit Alan explicitly said
    he /agreed/ with.


    You did not notice that he dishonestly changed the words
    of my quote and the agreed with these changed words. This
    is a deceptive tactic known as the strawman error.


    Mike.



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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From Mike Terry@3:633/280.2 to All on Sun Jun 29 03:38:43 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 28/06/2025 17:47, olcott wrote:
    On 6/28/2025 11:22 AM, Mike Terry wrote:
    On 28/06/2025 16:00, olcott wrote:
    On 6/27/2025 7:14 PM, Mike Terry wrote:
    On 27/06/2025 20:36, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

    Well, people here use the term "simulation" in a number of ways, right? >>>
    *There is only one correct way*

    That's patently rubbish.

    This is one of your major cognitive mistakes - believing that the squiggles which make up words
    have an absolute meaning independently of the people using them to (hopefully) communicate.


    void DDD()
    {
    HHH(DDD);
    return;
    }

    The correct simulation of DDD by HHH means that HHH simulates
    DDD and then emulates itself simulating DDD a number of times
    according to the semantics of C.

    "a number of times"???


    Do you know what a number is?
    In this case I am referring to every non-negative integer.

    a) Does a correct simulation need to simulate until its target computation terminates?


    There is no target computation here we only have the
    behavior that the input to HHH(DDD) specifies.


    ok I see you intend to be completely non-responsive, just as you were in the "diverging simulations"
    thread.

    I'll just point out for the record that you haven't provided any justification for accusing Alan or
    anybody else of lying to you. Indeed, your responses just show that you have no clue what other
    people are saying to you!

    Mike.


    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From dbush@3:633/280.2 to All on Sun Jun 29 03:13:41 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 12:03 PM, olcott wrote:
    On 6/28/2025 10:52 AM, dbush wrote:
    On 6/28/2025 11:46 AM, olcott wrote:
    On 6/28/2025 10:39 AM, dbush wrote:
    On 6/28/2025 11:30 AM, olcott wrote:
    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped the >>>>>>>> below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove you >>>>>> wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.


    No, you didn't give a definition of HHH, just gave a vauge
    incomplete description of what you think it does.


    It completely defines the generic notion of a simulating
    termination analyzer and

    It specifies every detail about HHH that is required
    to correctly determine whether or not DDD correctly
    simulated by HHH can possibly reach its own simulated
    "return" statement final halt state.


    But why would you say that when you've admitted on the record (see
    below) that DDD is not in fact correctly simulated by HHH?


    *I am not going to tolerate any misdirection to any other points*

    void DDD()
    {
    HHH(DDD);
    return;
    }

    The only point relevant to this forum is that DDD correctly
    simulated by HHH

    Is something that you have admitted on the record doesn't happen:


    On 5/5/2025 8:24 AM, dbush wrote:
    On 5/4/2025 11:03 PM, dbush wrote:
    On 5/4/2025 10:05 PM, olcott wrote:
    On 5/4/2025 7:23 PM, Richard Damon wrote:
    But HHH doesn't correct emulated DD by those rules, as those rules
    do not allow HHH to stop its emulation,

    Sure they do you freaking moron...

    Then show where in the Intel instruction manual that the execution of
    any instruction other than a HLT is allowed to stop instead of
    executing the next instruction.

    Failure to do so in your next reply, or within one hour of your next
    post on this newsgroup, will be taken as you official on-the-record
    admission that there is no such allowance and that HHH does NOT
    correctly simulate DD.

    Let the record show that Peter Olcott made the following post in this newsgroup after the above message:

    On 5/4/2025 11:04 PM, olcott wrote:
    D *WOULD NEVER STOP RUNNING UNLESS*
    indicates that professor Sipser was agreeing
    to hypotheticals AS *NOT CHANGING THE INPUT*

    You are taking
    *WOULD NEVER STOP RUNNING UNLESS*
    to mean *NEVER STOPS RUNNING* that is incorrect.

    And has made no attempt after over 9 hours to show where in the Intel instruction manual that execution is allowed to stop after any
    instruction other than HLT.

    Therefore, as per the above criteria:

    LET THE RECORD SHOW

    That Peter Olcott

    Has *officially* admitted

    That DD is NOT correctly simulated by HHH

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 03:27:33 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 12:13 PM, dbush wrote:
    On 6/28/2025 12:03 PM, olcott wrote:
    On 6/28/2025 10:52 AM, dbush wrote:
    On 6/28/2025 11:46 AM, olcott wrote:
    On 6/28/2025 10:39 AM, dbush wrote:
    On 6/28/2025 11:30 AM, olcott wrote:
    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped >>>>>>>>> the below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove
    you wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.


    No, you didn't give a definition of HHH, just gave a vauge
    incomplete description of what you think it does.


    It completely defines the generic notion of a simulating
    termination analyzer and

    It specifies every detail about HHH that is required
    to correctly determine whether or not DDD correctly
    simulated by HHH can possibly reach its own simulated
    "return" statement final halt state.


    But why would you say that when you've admitted on the record (see
    below) that DDD is not in fact correctly simulated by HHH?


    *I am not going to tolerate any misdirection to any other points*

    void DDD()
    {
    HHH(DDD);
    return;
    }

    The only point relevant to this forum is that DDD correctly
    simulated by HHH

    Is something that you have admitted on the record doesn't happen:


    *This is the only point that I will address*
    *Any attempt at changing the subject will*
    *be construed as dishonest*

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    Within the above specification DDD correctly simulated
    by HHH cannot possibly reach its own simulated "return"
    statement final halt state.

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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 03:35:32 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 12:13 PM, dbush wrote:
    On 6/28/2025 12:03 PM, olcott wrote:
    On 6/28/2025 10:52 AM, dbush wrote:
    On 6/28/2025 11:46 AM, olcott wrote:
    On 6/28/2025 10:39 AM, dbush wrote:
    On 6/28/2025 11:30 AM, olcott wrote:
    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped >>>>>>>>> the below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove
    you wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.


    No, you didn't give a definition of HHH, just gave a vauge
    incomplete description of what you think it does.


    It completely defines the generic notion of a simulating
    termination analyzer and

    It specifies every detail about HHH that is required
    to correctly determine whether or not DDD correctly
    simulated by HHH can possibly reach its own simulated
    "return" statement final halt state.


    But why would you say that when you've admitted on the record (see
    below) that DDD is not in fact correctly simulated by HHH?


    *I am not going to tolerate any misdirection to any other points*

    void DDD()
    {
    HHH(DDD);
    return;
    }

    The only point relevant to this forum is that DDD correctly
    simulated by HHH

    Is something that you have admitted on the record doesn't happen:



    (wrong function --- typo corrected)
    *This is the only point that I will address*
    *Any attempt at changing the subject will*
    *be construed as dishonest*

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    Within the above specification DDD correctly simulated
    by HHH cannot possibly reach its own simulated "return"
    statement final halt state.

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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From dbush@3:633/280.2 to All on Sun Jun 29 03:43:03 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 1:27 PM, olcott wrote:
    On 6/28/2025 12:13 PM, dbush wrote:
    On 6/28/2025 12:03 PM, olcott wrote:
    On 6/28/2025 10:52 AM, dbush wrote:
    On 6/28/2025 11:46 AM, olcott wrote:
    On 6/28/2025 10:39 AM, dbush wrote:
    On 6/28/2025 11:30 AM, olcott wrote:
    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped >>>>>>>>>> the below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here.
    Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove >>>>>>>> you wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.


    No, you didn't give a definition of HHH, just gave a vauge
    incomplete description of what you think it does.


    It completely defines the generic notion of a simulating
    termination analyzer and

    It specifies every detail about HHH that is required
    to correctly determine whether or not DDD correctly
    simulated by HHH can possibly reach its own simulated
    "return" statement final halt state.


    But why would you say that when you've admitted on the record (see
    below) that DDD is not in fact correctly simulated by HHH?


    *I am not going to tolerate any misdirection to any other points*

    void DDD()
    {
    HHH(DDD);
    return;
    }

    The only point relevant to this forum is that DDD correctly
    simulated by HHH

    Is something that you have admitted on the record doesn't happen:


    *This is the only point that I will address*
    *Any attempt at changing the subject will*
    *be construed as dishonest*

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH

    False, as it doesn't meet the requirements to be one:


    Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y:

    A solution to the halting problem is an algorithm H that computes the following mapping:

    (<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
    (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly


    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 04:08:50 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 12:38 PM, Mike Terry wrote:
    On 28/06/2025 17:47, olcott wrote:
    On 6/28/2025 11:22 AM, Mike Terry wrote:
    On 28/06/2025 16:00, olcott wrote:
    On 6/27/2025 7:14 PM, Mike Terry wrote:
    On 27/06/2025 20:36, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

    Well, people here use the term "simulation" in a number of ways,
    right?

    *There is only one correct way*

    That's patently rubbish.

    This is one of your major cognitive mistakes - believing that the
    squiggles which make up words have an absolute meaning independently
    of the people using them to (hopefully) communicate.


    void DDD()
    {
    HHH(DDD);
    return;
    }

    The correct simulation of DDD by HHH means that HHH simulates
    DDD and then emulates itself simulating DDD a number of times
    according to the semantics of C.

    "a number of times"???


    Do you know what a number is?
    In this case I am referring to every non-negative integer.

    a) Does a correct simulation need to simulate until its target
    computation terminates?


    There is no target computation here we only have the
    behavior that the input to HHH(DDD) specifies.


    ok I see you intend to be completely non-responsive, just as you were in
    the "diverging simulations" thread.

    I'll just point out for the record that you haven't provided any justification for accusing Alan or anybody else of lying to you.
    Indeed, your responses just show that you have no clue what other people
    are saying to you!

    Mike.


    *I wasn't clear enough*
    Here proof that Alan was dishonest by changing my
    quoted words and changing the time date stamp to
    make it more difficult to see that he was cheating.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

    In comp.theory olcott <polcott333@gmail.com> wrote:
    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has said otherwise.
    The conclusion is that the simulation by HHH is incorrect.

    On 6/27/2025 11:34 AM, olcott wrote:
    I know that DDD correctly simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Since HHH simulates DDD according to the semantics of the C
    programming language this simulation is necessarily correct.

    Disagreeing with this tries to get away with disagreeing
    with the semantics of the C programming language.
    How can that be honest?

    It is also the case that everyone besides Keith
    on comp.theory has disagreed with these words:

    DDD correctly simulated by HHH cannot possibly reach
    its own simulated "return" statement final halt state.

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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 04:16:22 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 12:43 PM, dbush wrote:
    On 6/28/2025 1:27 PM, olcott wrote:
    On 6/28/2025 12:13 PM, dbush wrote:
    On 6/28/2025 12:03 PM, olcott wrote:
    On 6/28/2025 10:52 AM, dbush wrote:
    On 6/28/2025 11:46 AM, olcott wrote:
    On 6/28/2025 10:39 AM, dbush wrote:
    On 6/28/2025 11:30 AM, olcott wrote:
    On 6/28/2025 10:21 AM, dbush wrote:
    On 6/28/2025 11:17 AM, olcott wrote:
    On 6/28/2025 10:14 AM, dbush wrote:
    On 6/28/2025 11:04 AM, olcott wrote:
    On 6/28/2025 2:43 AM, wij wrote:
    On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    The definition of HHH is missing.

    The definition is specified in this part that you
    dishonestly erased:

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When >>>>>>>>>>>> > HHH detects such a pattern it aborts its simulation >>>>>>>>>>>> > and returns 0.


    The dishonest one here is YOU, as it was not wij who snipped >>>>>>>>>>> the below in his reply but YOU:


    I stop at the first counter-factual mistake so I stop here. >>>>>>>>>> Everything else is ignored.


    In other words, you INTENTIONALLY don't read things that prove >>>>>>>>> you wrong.


    On 6/28/2025 2:43 AM, wij wrote:

    The definition of HHH is missing.

    On 6/27/2025 2:36 PM, olcott wrote:
    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.


    It is a verified fact that the definition of HHH was
    provided thus the claim that it was not provided is
    counter factual.


    No, you didn't give a definition of HHH, just gave a vauge
    incomplete description of what you think it does.


    It completely defines the generic notion of a simulating
    termination analyzer and

    It specifies every detail about HHH that is required
    to correctly determine whether or not DDD correctly
    simulated by HHH can possibly reach its own simulated
    "return" statement final halt state.


    But why would you say that when you've admitted on the record (see
    below) that DDD is not in fact correctly simulated by HHH?


    *I am not going to tolerate any misdirection to any other points*

    void DDD()
    {
    HHH(DDD);
    return;
    }

    The only point relevant to this forum is that DDD correctly
    simulated by HHH

    Is something that you have admitted on the record doesn't happen:


    *This is the only point that I will address*
    *Any attempt at changing the subject will*
    *be construed as dishonest*

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH

    False, as it doesn't meet the requirements to be one:


    My rebuttal to your change of subject is not appropriate
    for this group.

    Changes of subject in this group *WILL NOT BE TOLERATED*
    because that has always proved to be a gaslighting tactic.

    Whenever I make any irrefutable point the fake rebuttal
    always includes a change of subject.

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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Sun Jun 29 05:16:54 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/28/2025 12:38 PM, Mike Terry wrote:
    On 28/06/2025 17:47, olcott wrote:
    On 6/28/2025 11:22 AM, Mike Terry wrote:
    On 28/06/2025 16:00, olcott wrote:
    On 6/27/2025 7:14 PM, Mike Terry wrote:
    On 27/06/2025 20:36, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

    Well, people here use the term "simulation" in a number of ways,
    right?

    *There is only one correct way*

    That's patently rubbish.

    This is one of your major cognitive mistakes - believing that the
    squiggles which make up words have an absolute meaning independently
    of the people using them to (hopefully) communicate.


    void DDD()
    {
    HHH(DDD);
    return;
    }

    The correct simulation of DDD by HHH means that HHH simulates
    DDD and then emulates itself simulating DDD a number of times
    according to the semantics of C.

    "a number of times"???


    Do you know what a number is?
    In this case I am referring to every non-negative integer.

    a) Does a correct simulation need to simulate until its target
    computation terminates?


    There is no target computation here we only have the
    behavior that the input to HHH(DDD) specifies.


    ok I see you intend to be completely non-responsive,

    In a c/c++ group when talking about the behavior of an
    input to a simulating termination analyzer we only
    examine what DDD simulated by HHH (according to the
    semantics of the C programming language) actually does.

    There is no theory of computation "target" computation
    in this case.

    just as you were in
    the "diverging simulations" thread.

    I'll just point out for the record that you haven't provided any justification for accusing Alan or anybody else of lying to you.
    Indeed, your responses just show that you have no clue what other people
    are saying to you!

    Mike.





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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Mon Jun 30 01:41:56 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- Liars on comp.theory

    On 6/27/2025 7:14 PM, Mike Terry wrote:
    On 27/06/2025 20:36, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

    Well, people here use the term "simulation" in a number of ways, right? Like I've pointed out to you on several occasions. Maybe you should consider a simple misunderstanding over terminology before assuming bad intentions.

    So what does Alan mean by "the simulation by HHH is incorrect",
    exactly? (And why do you think it is incorrect?)


    *He can't possibly mean anything truthful*
    *He can't possibly mean anything truthful*
    *He can't possibly mean anything truthful*

    void DDD()
    {
    HHH(DDD);
    return;
    }

    At the C level HHH simulates DDD that calls HHH(DDD)
    that DDD simulates DDD that calls HHH(DDD)
    that DDD simulates DDD that calls HHH(DDD)
    that DDD simulates DDD that calls HHH(DDD)
    that DDD simulates DDD that calls HHH(DDD)

    until HHH correctly determines that DDD simulated by HHH
    (according to the semantics of the C programming language)
    cannot possibly reach its own simulated "return" instruction
    (final halt state).

    *Here is the same thing at the x86 machine code level*
    (what HHH actually sees and analyzes)

    _DDD()
    [00002192] 55 push ebp
    [00002193] 8bec mov ebp,esp
    [00002195] 6892210000 push 00002192 // push DDD
    [0000219a] e833f4ffff call 000015d2 // call HHH
    [0000219f] 83c404 add esp,+04
    [000021a2] 5d pop ebp
    [000021a3] c3 ret
    Size in bytes:(0018) [000021a3]

    The x86 source code of DDD specifies that this emulated
    DDD cannot possibly reach its own emulated "ret" instruction
    final halt state when emulated by HHH according to the
    semantics of the x86 language.

    That is a question for PO, rather than Alan, since it is PO who claims
    Alan is lying...

    Mike.



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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)
  • From olcott@3:633/280.2 to All on Mon Jun 30 01:48:47 2025
    Subject: Re: DDD correctly simulated by HHH can't possibly reach its own
    "return" statement --- (Typo corrected)

    On 6/27/2025 7:14 PM, Mike Terry wrote:
    On 27/06/2025 20:36, olcott wrote:
    I am only here for the validation of the behavior
    of DDD correctly simulated by HHH.

    I have included proof that the people on comp.theory
    lied about this at the bottom.

    typedef void (*ptr)();
    int HHH(ptr P);

    void DDD()
    {
    HHH(DDD);
    return;
    }

    int main()
    {
    HHH(DDD);
    DDD();
    }

    Termination Analyzer HHH simulates its input until
    it detects a non-terminating behavior pattern. When
    HHH detects such a pattern it aborts its simulation
    and returns 0.

    On 6/27/2025 12:27 PM, Alan Mackenzie wrote:
    In comp.theory olcott <polcott333@gmail.com
    wrote:

    I know that DDD .... simulated by HHH cannot
    possibly reach its own simulated "return" statement
    final halt state because the execution trace
    conclusively proves this.

    Everybody else knows this, too, and nobody has
    said otherwise. *The conclusion is that the*
    *simulation by HHH is incorrect*


    *That last sentence is an intentional falsehood*

    Well, people here use the term "simulation" in a number of ways, right? Like I've pointed out to you on several occasions. Maybe you should consider a simple misunderstanding over terminology before assuming bad intentions.

    So what does Alan mean by "the simulation by HHH is incorrect",
    exactly? (And why do you think it is incorrect?)





    *He can't possibly mean anything truthful*
    *He can't possibly mean anything truthful*
    *He can't possibly mean anything truthful*

    void DDD()
    {
    HHH(DDD);
    return;
    }

    At the C level
    HHH simulates DDD that calls HHH(DDD)
    that simulates DDD that calls HHH(DDD)
    that simulates DDD that calls HHH(DDD)
    that simulates DDD that calls HHH(DDD)
    that simulates DDD that calls HHH(DDD)

    until HHH correctly determines that DDD simulated by HHH
    (according to the semantics of the C programming language)
    cannot possibly reach its own simulated "return" instruction
    (final halt state).

    *Here is the same thing at the x86 machine code level*
    (what HHH actually sees and analyzes)

    _DDD()
    [00002192] 55 push ebp
    [00002193] 8bec mov ebp,esp
    [00002195] 6892210000 push 00002192 // push DDD
    [0000219a] e833f4ffff call 000015d2 // call HHH
    [0000219f] 83c404 add esp,+04
    [000021a2] 5d pop ebp
    [000021a3] c3 ret
    Size in bytes:(0018) [000021a3]

    The x86 source code of DDD specifies that this emulated
    DDD cannot possibly reach its own emulated "ret" instruction
    final halt state when emulated by HHH according to the
    semantics of the x86 language.

    That is a question for PO, rather than Alan, since it is PO who claims
    Alan is lying...

    Mike.



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

    --- MBSE BBS v1.1.1 (Linux-x86_64)
    * Origin: A noiseless patient Spider (3:633/280.2@fidonet)