1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: I am claiming that these exact words are necessarily true

    From Richard Damon@21:1/5 to olcott on Sun Oct 13 09:12:23 2024
    On 10/13/24 8:40 AM, olcott wrote:
    I am not and never have been claiming anything
    about incorrect paraphrases of these exact words:

    *HHH rejects DDD as non terminating*

    Which judst makes HHH wrong, since DDD will terminate, since that term
    applies to the PROGRAM that the input represents., and if HHH rejects
    it, it returns to its caller, and thus DDD will halt.


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

    When HHH is an x86 emulation based termination analyzer
    then each DDD emulated by any HHH that it calls never returns.

    The emulation of DDD by HHH never reaches a final state, but it HHH
    aborts its emulation and return 0, then the PROGRAM DDD will return.


    Each of the directly executed HHH emulator/analyzers that returns
    0 correctly reports the above non-terminating behavior of its input.

    No, since termination is a property of the PROGRAM, and not a partial
    emuation of it, you answer is proven wrong, and you are guilty of using
    unsound logic.


    *Fully operational code is here* https://github.com/plolcott/x86utm/blob/master/Halt7.c https:// github.com/plolcott/x86utm


    Which shows that all those DDD do terminate.

    It also proves you have been lying that your decider is a pure function
    and thus nothing you say has any validity.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sun Oct 13 09:29:35 2024
    On 10/13/24 9:17 AM, olcott wrote:
    On 10/13/2024 8:12 AM, Richard Damon wrote:
    On 10/13/24 8:40 AM, olcott wrote:
    I am not and never have been claiming anything
    about incorrect paraphrases of these exact words:

    *HHH rejects DDD as non terminating*

    Which judst makes HHH wrong, since DDD will terminate, since that term
    applies to the PROGRAM that the input represents., and if HHH rejects
    it, it returns to its caller, and thus DDD will halt.


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

    When HHH is an x86 emulation based termination analyzer
    then each DDD emulated by any HHH that it calls never returns.

    The emulation of DDD by HHH never reaches a final state, but it HHH
    aborts its emulation and return 0, then the PROGRAM DDD will return.


    Rebutting an incorrect paraphrase of my exact words
    <is> the strawman deception.


    Each of the directly executed HHH emulator/analyzers that returns
    0 correctly reports the above non-terminating behavior of its input.

    No, since termination is a property of the PROGRAM, and not a partial
    emuation of it, you answer is proven wrong, and you are guilty of
    using unsound logic.


    Rebutting an incorrect paraphrase of my exact words
    <is> the strawman deception.


    But I rebuted your exact words. The fact that they are equivical is your
    own fault, since the other meaning, the one you seem to want to use, is
    based on a category error, it can't be correct. (partial emulation do
    not have a non-terminating property)


    *Fully operational code is here*
    https://github.com/plolcott/x86utm/blob/master/Halt7.c https://
    github.com/plolcott/x86utm


    Which shows that all those DDD do terminate.

    It also proves you have been lying that your decider is a pure
    function and thus nothing you say has any validity.



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sun Oct 13 14:49:35 2024
    On 10/13/24 10:03 AM, olcott wrote:
    On 10/13/2024 8:29 AM, Richard Damon wrote:
    On 10/13/24 9:17 AM, olcott wrote:
    On 10/13/2024 8:12 AM, Richard Damon wrote:
    On 10/13/24 8:40 AM, olcott wrote:
    I am not and never have been claiming anything
    about incorrect paraphrases of these exact words:

    *HHH rejects DDD as non terminating*

    Which judst makes HHH wrong, since DDD will terminate, since that
    term applies to the PROGRAM that the input represents., and if HHH
    rejects it, it returns to its caller, and thus DDD will halt.


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

    When HHH is an x86 emulation based termination analyzer
    then each DDD emulated by any HHH that it calls never returns.

    The emulation of DDD by HHH never reaches a final state, but it HHH
    aborts its emulation and return 0, then the PROGRAM DDD will return.


    Rebutting an incorrect paraphrase of my exact words
    <is> the strawman deception.


    Each of the directly executed HHH emulator/analyzers that returns
    0 correctly reports the above non-terminating behavior of its input.

    No, since termination is a property of the PROGRAM, and not a
    partial emuation of it, you answer is proven wrong, and you are
    guilty of using unsound logic.


    Rebutting an incorrect paraphrase of my exact words
    <is> the strawman deception.


    But I rebuted your exact words.

    That statement is counter-factual.


    No, your statement is just a blantent lie.

    Where did you refute what I said, or are you claiming I didn't say anything?

    You are just proving you are nothing but an out and out liar.

    I specifically refer to whether or not a specific C function
    (source-code provided) reaches its own "return" instruction.

    Right, and such behavior is only defined with the definition of every
    thing that function calls.


    This <is> the correct measure for the termination analysis
    of C functions.

    Right, but it included the ACTUAL behavior of the HHH that DDD calls.


    Automated Termination Analysis of C Programs https://publications.rwth-aachen.de/record/972440/files/972440.pdf
    Figure 5.3: Non-Terminating C Function

    Right, which looks at code that doesn't actually return, because it gets
    stuck in an actual infinte loop.

    Not that the analyzer can't emulate to the return instruction, but code
    that actually doesn't return.

    Your problem is you have only shown that DDD won't return if HHH is
    defined to never aborts its emulation in this case. SInce it *IS*
    defined that way, you logic is built on a false premise and doesn't
    actually assert its conclusion,


    You try to get away with the pure bluster of declaring that
    this C function is not even a C function.

    Where did I say that.

    The C function of the example is totally self-contained, and refers to
    nothing else, so can be analysize in isolation.

    Your DDD refers to HHH, so its termination analysis needs to include the behavior of HHH.

    If you try to use that form of analysis on DDD, you will find that DDD
    will terminate if and only if HHH aborts its emulation and returns.

    THAT ISN'T THE DEFINITION OF NON-TERMINATION, as once the code of HHH is defined so that it does abort, then the analysis will say that DDD will
    be halting, thus HHH can not use that as an "excuse" to abort and claim non-halting.


    The fact that they are equivical is your own fault, since the other
    meaning, the one you seem to want to use, is based on a category
    error, it can't be correct. (partial emulation do not have a non-
    terminating property)



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sun Oct 13 19:49:14 2024
    On 10/13/24 3:17 PM, olcott wrote:
    On 10/13/2024 1:49 PM, Richard Damon wrote:
    On 10/13/24 10:03 AM, olcott wrote:
    On 10/13/2024 8:29 AM, Richard Damon wrote:
    On 10/13/24 9:17 AM, olcott wrote:
    On 10/13/2024 8:12 AM, Richard Damon wrote:
    On 10/13/24 8:40 AM, olcott wrote:
    I am not and never have been claiming anything
    about incorrect paraphrases of these exact words:

    *HHH rejects DDD as non terminating*

    Which judst makes HHH wrong, since DDD will terminate, since that
    term applies to the PROGRAM that the input represents., and if HHH >>>>>> rejects it, it returns to its caller, and thus DDD will halt.


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

    When HHH is an x86 emulation based termination analyzer
    then each DDD emulated by any HHH that it calls never returns.

    The emulation of DDD by HHH never reaches a final state, but it
    HHH aborts its emulation and return 0, then the PROGRAM DDD will
    return.


    Rebutting an incorrect paraphrase of my exact words
    <is> the strawman deception.


    Each of the directly executed HHH emulator/analyzers that returns >>>>>>> 0 correctly reports the above non-terminating behavior of its input. >>>>>>
    No, since termination is a property of the PROGRAM, and not a
    partial emuation of it, you answer is proven wrong, and you are
    guilty of using unsound logic.


    Rebutting an incorrect paraphrase of my exact words
    <is> the strawman deception.


    But I rebuted your exact words.

    That statement is counter-factual.


    No, your statement is just a blantent lie.

    Where did you refute what I said, or are you claiming I didn't say
    anything?

    You are just proving you are nothing but an out and out liar.

    I specifically refer to whether or not a specific C function
    (source-code provided) reaches its own "return" instruction.

    Right, and such behavior is only defined with the definition of every
    thing that function calls.


    Finally you said something that is correct.

    So, the Input representing "DDD" must include the code of HHH.

    It doesn't (per your arguement) so the input is just invalid.



    This <is> the correct measure for the termination analysis
    of C functions.

    Right, but it included the ACTUAL behavior of the HHH that DDD calls.


    Yes you are correct again.

    So, since HHH(DDD) returns 0, then that *IS* the behavior that HHH needs
    to presume (or deduce) when emulating that instuction.



    Automated Termination Analysis of C Programs
    https://publications.rwth-aachen.de/record/972440/files/972440.pdf
    Figure 5.3: Non-Terminating C Function

    Right, which looks at code that doesn't actually return, because it
    gets stuck in an actual infinte loop.



    The point here is that termination analysis does
    not only refer to complete programs as you said

    But a subroutine, with all the subroutines it uses *IS* a "complete
    program" per the definitions.


    No, since termination is a property of the PROGRAM

    it also applies to C functions proving that you were
    wrong about this.



    But only when included *ALL* the code called by it.

    You are just proving that you are either totally ignorant of what you
    are talking about, or just trying to be dishonest, but so stupid your
    errors are in plain sight.

    Sorry, that *IS* the facts, but you seem to be unable to undertstand them.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sun Oct 13 20:12:16 2024
    On 10/13/24 8:06 PM, olcott wrote:
    On 10/13/2024 6:49 PM, Richard Damon wrote:
    On 10/13/24 3:17 PM, olcott wrote:
    On 10/13/2024 1:49 PM, Richard Damon wrote:
    On 10/13/24 10:03 AM, olcott wrote:
    On 10/13/2024 8:29 AM, Richard Damon wrote:
    On 10/13/24 9:17 AM, olcott wrote:
    On 10/13/2024 8:12 AM, Richard Damon wrote:
    On 10/13/24 8:40 AM, olcott wrote:
    I am not and never have been claiming anything
    about incorrect paraphrases of these exact words:

    *HHH rejects DDD as non terminating*

    Which judst makes HHH wrong, since DDD will terminate, since
    that term applies to the PROGRAM that the input represents., and >>>>>>>> if HHH rejects it, it returns to its caller, and thus DDD will >>>>>>>> halt.


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

    When HHH is an x86 emulation based termination analyzer
    then each DDD emulated by any HHH that it calls never returns. >>>>>>>>
    The emulation of DDD by HHH never reaches a final state, but it >>>>>>>> HHH aborts its emulation and return 0, then the PROGRAM DDD will >>>>>>>> return.


    Rebutting an incorrect paraphrase of my exact words
    <is> the strawman deception.


    Each of the directly executed HHH emulator/analyzers that returns >>>>>>>>> 0 correctly reports the above non-terminating behavior of its >>>>>>>>> input.

    No, since termination is a property of the PROGRAM, and not a
    partial emuation of it, you answer is proven wrong, and you are >>>>>>>> guilty of using unsound logic.


    Rebutting an incorrect paraphrase of my exact words
    <is> the strawman deception.


    But I rebuted your exact words.

    That statement is counter-factual.


    No, your statement is just a blantent lie.

    Where did you refute what I said, or are you claiming I didn't say
    anything?

    You are just proving you are nothing but an out and out liar.

    I specifically refer to whether or not a specific C function
    (source-code provided) reaches its own "return" instruction.

    Right, and such behavior is only defined with the definition of
    every thing that function calls.


    Finally you said something that is correct.

    So, the Input representing "DDD" must include the code of HHH.

    It doesn't (per your arguement) so the input is just invalid.



    This <is> the correct measure for the termination analysis
    of C functions.

    Right, but it included the ACTUAL behavior of the HHH that DDD calls.


    Yes you are correct again.

    So, since HHH(DDD) returns 0, then that *IS* the behavior that HHH
    needs to presume (or deduce) when emulating that instuction.



    Automated Termination Analysis of C Programs
    https://publications.rwth-aachen.de/record/972440/files/972440.pdf
    Figure 5.3: Non-Terminating C Function

    Right, which looks at code that doesn't actually return, because it
    gets stuck in an actual infinte loop.



    The point here is that termination analysis does
    not only refer to complete programs as you said

    But a subroutine, with all the subroutines it uses *IS* a "complete
    program" per the definitions.


    No it is not it has no main().

    Which is a requirement for the language, and only for HOSTED system.

    It is not the requirement for a program in Computation Theory.



    No, since termination is a property of the PROGRAM

    it also applies to C functions proving that you were
    wrong about this.



    But only when included *ALL* the code called by it.

    You are just proving that you are either totally ignorant of what you
    are talking about, or just trying to be dishonest, but so stupid your
    errors are in plain sight.

    Sorry, that *IS* the facts, but you seem to be unable to undertstand
    them.

    ChatGPT does point out all of your mistakes.
    When you point out its mistake it explains how any why you are wrong.


    Nope, it explains that in REALITY the input is non-halting, and the
    repeats the lies you gave it about being able to decide on wrong conditions.

    Sorry, you are just showing your ignorance, and that you think lying is accceptable.

    Until you can explain how, when the ONLY actual requuirement is based on
    the behavior of the program described, which has DDD call the HHH(DDD)
    that does return 0 and thus DDD Halts, and thus DDD halt, it can
    possible be "correct" to say it is non-terminating.

    Sorry, your brain is just totally exploded by the contradictions you
    have put into your logic system.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From joes@21:1/5 to All on Mon Oct 14 08:23:09 2024
    Am Sun, 13 Oct 2024 19:06:04 -0500 schrieb olcott:
    On 10/13/2024 6:49 PM, Richard Damon wrote:
    On 10/13/24 3:17 PM, olcott wrote:
    On 10/13/2024 1:49 PM, Richard Damon wrote:
    On 10/13/24 10:03 AM, olcott wrote:
    On 10/13/2024 8:29 AM, Richard Damon wrote:
    On 10/13/24 9:17 AM, olcott wrote:
    On 10/13/2024 8:12 AM, Richard Damon wrote:
    On 10/13/24 8:40 AM, olcott wrote:

    I specifically refer to whether or not a specific C function
    (source-code provided) reaches its own "return" instruction.
    Right, and such behavior is only defined with the definition of every
    thing that function calls.
    Finally you said something that is correct.
    So, the Input representing "DDD" must include the code of HHH.

    This <is> the correct measure for the termination analysis of C
    functions.
    Right, but it included the ACTUAL behavior of the HHH that DDD calls.
    Yes you are correct again.
    So, since HHH(DDD) returns 0, then that *IS* the behavior that HHH
    needs to presume (or deduce) when emulating that instuction.

    Automated Termination Analysis of C Programs
    https://publications.rwth-aachen.de/record/972440/files/972440.pdf
    Figure 5.3: Non-Terminating C Function
    Right, which looks at code that doesn't actually return, because it
    gets stuck in an actual infinte loop.
    The point here is that termination analysis does not only refer to
    complete programs as you said
    But a subroutine, with all the subroutines it uses *IS* a "complete
    program" per the definitions.
    No it is not it has no main().
    You can put it as the sole call to main() and it will compile.

    No, since termination is a property of the PROGRAM
    it also applies to C functions proving that you were wrong about this.
    But only when included *ALL* the code called by it.

    --
    Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
    It is not guaranteed that n+1 exists for every n.

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