1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: DDD correctly emulated by HHH is INCorrectly rejected as non-haltin

    From Richard Damon@21:1/5 to olcott on Sat Jul 13 09:15:10 2024
    On 7/13/24 7:53 AM, olcott wrote:
    On 7/13/2024 3:48 AM, joes wrote:
    Am Fri, 12 Jul 2024 22:00:08 -0500 schrieb olcott:
    On 7/12/2024 6:41 PM, Richard Damon wrote:
    On 7/12/24 7:19 PM, olcott wrote:
    On 7/12/2024 5:56 PM, Richard Damon wrote:
    On 7/12/24 10:56 AM, olcott wrote:

    Thus each HHH element of the above infinite set of HHH/DDD pairs is >>>>>>> necessarily correct to reject its DDD as non-halting.

    Nope.
    NONE Of them CORRECTLY rejected itS DDD as non-halting and you are >>>>>> shown to be ignorant of what you are talking about.
    The HHH that did a partial emulation got the wrong answer, because >>>>>> THEIR DDD will halt. and the HHH that doen't abort never get around >>>>>> to rejecting its DDD as non-halting.

    When no DDD of every HHH/DDD that can possibly exist halts then each >>>>> HHH that rejects its DDD as non-halting is necessarily correct.
    *No double-talk and weasel words can overcome that*

    Which is just your double-talk to try to redefine what halting means.

    You try to cut my airtight proof up in little pieces and fail. Every
    rebuttal that you make has disagreeing with the semantics of the x86
    language as its basis.
    Where does it disagree?!


    *This proves that every rebuttal is wrong somewhere*
    No DDD instance of each HHH/DDD pair of the infinite set of
    every HHH/DDD pair ever reaches past its own machine address of
    0000216b and halts thus proving that every HHH is correct to
    reject its input DDD as non-halting.


    But every DDD based on an HHH that stops its emulation and returns, will
    itself return when fully correctly emulated or run. It is only HHH
    INCORRECT because it is only PARTIAL emulation of that DDD that doesn't
    make it to the end.

    PARTIAL emulations do not, by themselves, prove non-halting.

    Your disagreeing with the actual details of the x86 language isn't
    allowed and shows how much of a pathologcial liar you are. You just
    can't understand the difference between Truth, which says what actually
    is, and Knownledge, which says what we know of what is, perhaps because
    you think you must be "God" and know everythibg that is, but you are NOT
    God.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Jul 13 10:14:20 2024
    On 7/13/24 9:34 AM, olcott wrote:
    On 7/13/2024 8:24 AM, joes wrote:
    Am Sat, 13 Jul 2024 08:04:01 -0500 schrieb olcott:
    On 7/13/2024 7:20 AM, Fred. Zwarts wrote:
    Op 13.jul.2024 om 13:39 schreef olcott:
    On 7/13/2024 3:15 AM, Fred. Zwarts wrote:
    Op 13.jul.2024 om 01:19 schreef olcott:
    On 7/12/2024 5:56 PM, Richard Damon wrote:
    On 7/12/24 10:56 AM, olcott wrote:

    You have a wrong understanding of the semantics of the x86 language.
    You think that the x86 language specifies that skipping instructions do >>>> not change the behaviour of a program.
    Do you understand that a simulator that aborts does not run forever?

    As soon as the decider correctly determines that itself would never halt >>> unless is aborts the simulation of its input the decider is required to
    abort this simulation.
    Which decider is aborting here, the simulated or the outer one?
    A decider always halts, so it cannot find itself non-halting.


    The executed decider is always correct to abort the
    simulation of any damn thing that would cause itself
    to never halt.


    But the DDD that HHH was given (which includes the code of the specific
    HHH that it is using) can be properly simulated by a variant of HHH that doesn't abort.

    The issue is you logic is just invalid because it ignores the
    fundamental property the code does what it does so the only thing that
    causes it to do anytnhing is its code.

    The HHH that never halts isn't the same HHH that aborts, and the DDD
    that the two are emulating are DIFFERENT (due to the implied inclusion
    of the code of the HHH that they call), so are not comparable.

    Your LOGIC is just invalid as it assume two different things are the
    same thing, which is just a part of the insanity that seems to infect you.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Jul 13 10:45:24 2024
    On 7/13/24 10:31 AM, olcott wrote:
    On 7/13/2024 9:21 AM, joes wrote:
    Am Sat, 13 Jul 2024 08:34:55 -0500 schrieb olcott:
    On 7/13/2024 8:24 AM, joes wrote:
    Am Sat, 13 Jul 2024 08:04:01 -0500 schrieb olcott:
    On 7/13/2024 7:20 AM, Fred. Zwarts wrote:
    Op 13.jul.2024 om 13:39 schreef olcott:
    On 7/13/2024 3:15 AM, Fred. Zwarts wrote:
    Op 13.jul.2024 om 01:19 schreef olcott:
    On 7/12/2024 5:56 PM, Richard Damon wrote:
    On 7/12/24 10:56 AM, olcott wrote:

    You have a wrong understanding of the semantics of the x86 language. >>>>>> You think that the x86 language specifies that skipping instructions >>>>>> do not change the behaviour of a program.
    Do you understand that a simulator that aborts does not run forever?

    As soon as the decider correctly determines that itself would never
    halt unless is aborts the simulation of its input the decider is
    required to abort this simulation.
    Which decider is aborting here, the simulated or the outer one?
    A decider always halts, so it cannot find itself non-halting.
    The executed decider is always correct to abort the simulation of any
    damn thing that would cause itself to never halt.

    Which is definitely not itself. Simulating a decider is guaranteed to
    halt. Same as a simulator that aborts.


    It cannot abort the simulation of itself because itself
    is not simulated.



    Then either it didn't correctly simulate the Call HHH instruction in
    DDD, or you agree that aborting a simulation of something doesn't abort
    that thing, so HHH aborting the simulation of DDD dosn't about the
    actual DDD, which continues and halt despite HHH saying it doesn't.

    Thus, you are admitting that you statement is just false.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Sat Jul 13 19:32:54 2024
    On 7/13/24 6:47 PM, olcott wrote:
    On 7/13/2024 5:40 PM, joes wrote:
    Am Sat, 13 Jul 2024 09:31:33 -0500 schrieb olcott:
    On 7/13/2024 9:21 AM, joes wrote:
    Am Sat, 13 Jul 2024 08:34:55 -0500 schrieb olcott:
    On 7/13/2024 8:24 AM, joes wrote:
    Am Sat, 13 Jul 2024 08:04:01 -0500 schrieb olcott:
    On 7/13/2024 7:20 AM, Fred. Zwarts wrote:
    Op 13.jul.2024 om 13:39 schreef olcott:
    On 7/13/2024 3:15 AM, Fred. Zwarts wrote:
    Op 13.jul.2024 om 01:19 schreef olcott:
    On 7/12/2024 5:56 PM, Richard Damon wrote:
    On 7/12/24 10:56 AM, olcott wrote:

    As soon as the decider correctly determines that itself would never >>>>>>> halt unless is aborts the simulation of its input the decider is >>>>>>> required to abort this simulation.
    Which decider is aborting here, the simulated or the outer one?
    A decider always halts, so it cannot find itself non-halting.
    The executed decider is always correct to abort the simulation of any >>>>> damn thing that would cause itself to never halt.
    Which is definitely not itself. Simulating a decider is guaranteed to
    halt. Same as a simulator that aborts.
    It cannot abort the simulation of itself because itself is not
    simulated.
    It certainly is, because the DDD that it simulates calls HHH.


    You are thinking of its twin brother.


    Then so is the DDD, and you are forgetting that all copies of a
    determinstic program act the same.

    Something you have implicitly agreed to byu refusing to show how it
    could differ.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Mon Jul 15 22:18:25 2024
    On 7/15/24 11:52 AM, olcott wrote:
    On 7/15/2024 9:04 AM, joes wrote:
    Am Mon, 15 Jul 2024 07:23:57 -0500 schrieb olcott:
    On 7/15/2024 3:59 AM, joes wrote:
    Am Sun, 14 Jul 2024 22:35:03 -0500 schrieb olcott:
    On 7/14/2024 10:02 PM, Mike Terry wrote:

    Any input that must be aborted to prevent the non termination of
    simulating termination analyzer HHH necessarily specifies non-halting >>>>> behavior or it would never need to be aborted.
    It's just that the input HHH halts and does not need to be aborted.
    At the point that it is aborted it did need to be aborted
    Because it hadn't halted yet?

    Because HHH has seen a repeating state that proves that DDD
    correctly emulated by HHH cannot possibly ever stop running
    unless aborted.

    No, HHH *THINKS* it has seen repeating state because is has the wrong
    model for the HHH that it chose not to emulate (and thus HHH fails to
    emulate correctly). It is a DIFFERENT DDD that is built on a DIFFERENT
    HHH whose correct semulation never stops, of DDD is just not a program
    at all and you whole system is just a LIE.

    Remember, programs constain ALL their code, including everything they
    call, like HHH.


    That you fail to understand a that there is a repeating state
    or fail to understand that a repeating state proves this is
    less than no rebuttal at all.

    Why should it have halted, it will do so
    in the future. Do you place arbitrary lifetime limits on all programs?



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