1. Forum
  2. Usenet
  3. COMP.THEORY

  • Re: Infinite set of HHH/DDD pairs --- truisms

    From Fred. Zwarts@21:1/5 to All on Mon Jul 22 19:45:55 2024
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said:
    On 7/19/2024 3:51 AM, Mikko wrote:

    Anyway you did not say that some HHHᵢ can simulate the
    corresponding DDDᵢ to its termination. And each DDDᵢ does
    terminate, whether simulated or not.


    Then DDD correctly simulated by any pure function HHH cannot possibly >>>>> reach its own return instruction and halt, therefore every HHH is
    correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting
    comoputation as non-halting.
    In each of the above instances DDD never reaches its return instruction
    and halts. This proves that HHH is correct to report that its DDD never
    halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly emulated by its
    HHH and this HHH never aborts its simulation neither DDD nor HHH ever
    stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the simulation of >>> its corresponding DDD as required by the design spec that every partial
    halt decider must halt and is otherwise not any kind of decider at all.
    Like Fred recognised a while ago, you are arguing as if HHH didn't abort.

    That HHH is required to abort its simulation of DDD conclusively proves
    that this DDD never halts.
    You've got it the wrong way around.


    I am talking about hypothetical possible ways that HHH could be encoded.
    (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.

    Therefore (a) is correct and (b) is incorrect according to the
    design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not need to be
    aborted when simulated, because it already halts on its own.
    HHH, when simulated by itself, runs one cycle behind its simulator.
    Therefore, the simulating always aborts, when it is not needed, because
    the simulated HHH is encoded to abort one cycle later.
    Therefore, the simulation is incomplete and, therefore, incorrect.


    It is also a truism that any input that must be aborted
    is a non-halting input.

    It is also a truism that a halting program does not need to be aborted.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Mon Jul 22 20:16:59 2024
    Op 22.jul.2024 om 19:51 schreef olcott:
    On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said:
    On 7/19/2024 3:51 AM, Mikko wrote:

    Anyway you did not say that some HHHᵢ can simulate the
    corresponding DDDᵢ to its termination. And each DDDᵢ does >>>>>>>>>> terminate, whether simulated or not.


    Then DDD correctly simulated by any pure function HHH cannot
    possibly
    reach its own return instruction and halt, therefore every HHH is >>>>>>> correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting
    comoputation as non-halting.
    In each of the above instances DDD never reaches its return
    instruction
    and halts. This proves that HHH is correct to report that its DDD
    never
    halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly emulated by
    its
    HHH and this HHH never aborts its simulation neither DDD nor HHH ever >>>>> stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the
    simulation of
    its corresponding DDD as required by the design spec that every
    partial
    halt decider must halt and is otherwise not any kind of decider at
    all.
    Like Fred recognised a while ago, you are arguing as if HHH didn't
    abort.

    That HHH is required to abort its simulation of DDD conclusively
    proves
    that this DDD never halts.
    You've got it the wrong way around.


    I am talking about hypothetical possible ways that HHH could be encoded. >>> (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.

    Therefore (a) is correct and (b) is incorrect according to the
    design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not need to be
    aborted when simulated, because it already halts on its own.

    When no HHH(DDD) ever aborts its input then HHH never halts
    conclusively proving that some HHH must abort its input.


    Indeed, but dreaming of an HHH that does not abort is irrelevant when we consider a HHH that is encoded to abort.
    The HHH that aborts, simulates itself: the HHH that aborts. No HHH that
    does not abort is involved.
    When a HHH aborts, it is not needed to abort its simulation, because it
    will halt by its own.
    So for any HHH, whether it aborts or not, we can say:
    HHH cannot possibly simulate itself correctly up to the end.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Mon Jul 22 21:30:34 2024
    Op 22.jul.2024 om 20:31 schreef olcott:
    On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said:
    On 7/19/2024 3:51 AM, Mikko wrote:

    Anyway you did not say that some HHHᵢ can simulate the
    corresponding DDDᵢ to its termination. And each DDDᵢ does >>>>>>>>>> terminate, whether simulated or not.


    Then DDD correctly simulated by any pure function HHH cannot
    possibly
    reach its own return instruction and halt, therefore every HHH is >>>>>>> correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting
    comoputation as non-halting.
    In each of the above instances DDD never reaches its return
    instruction
    and halts. This proves that HHH is correct to report that its DDD
    never
    halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly emulated by
    its
    HHH and this HHH never aborts its simulation neither DDD nor HHH ever >>>>> stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the
    simulation of
    its corresponding DDD as required by the design spec that every
    partial
    halt decider must halt and is otherwise not any kind of decider at
    all.
    Like Fred recognised a while ago, you are arguing as if HHH didn't
    abort.

    That HHH is required to abort its simulation of DDD conclusively
    proves
    that this DDD never halts.
    You've got it the wrong way around.


    I am talking about hypothetical possible ways that HHH could be encoded. >>> (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.

    Therefore (a) is correct and (b) is incorrect according to the
    design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not need to be
    aborted when simulated, because it already halts on its own.

    You must have attention deficit disorder.
    (a) At least one HHH aborts.
    (b) No HHH ever aborts.

    Every X has property Y or not, there is no inbetween.

    Do you have difficulty reading and writing English?

    If every X has property Y or not, then it is clear that every HHH abort
    or not. In other words, some HHH abort, some HHH do not abort.
    Both produce an incorrect simulation, when they try to simulate themselves.

    (a) Some HHH abort and they cause an incorrect simulation when
    simulating themselves, because they abort too soon, making the
    simulation incomplete and, therefore, incorrect.
    (b) Some HHH never abort and they do not finish the simulation of
    themselves.
    Both (a) and (b) result in incorrect simulations.
    HHH cannot possibly simulate itself correctly.

    When analysing (a), there is no need to dream about (b). The HHH that
    aborts will simulate itself, a HHH that aborts. So, in that case no
    abort is needed for the simulated HHH, because the simulated HHH is
    encoded to abort. However, the simulating HHH performs the unneeded
    abort, because it is encoded to do so.

    When analysing (b), there is no need to dream about (a). The HHH that
    does not abort, should abort its own simulation, but cannot do that,
    because it is encode to never abort.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From joes@21:1/5 to All on Mon Jul 22 21:19:18 2024
    Am Mon, 22 Jul 2024 14:57:21 -0500 schrieb olcott:
    On 7/22/2024 2:30 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 20:31 schreef olcott:
    On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said:
    On 7/19/2024 3:51 AM, Mikko wrote:

    Then DDD correctly simulated by any pure function HHH cannot >>>>>>>>> possibly reach its own return instruction and halt, therefore >>>>>>>>> every HHH is correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting
    comoputation as non-halting.
    In each of the above instances DDD never reaches its return
    instruction and halts. This proves that HHH is correct to report >>>>>>> that its DDD never halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly emulated >>>>>>> by its HHH and this HHH never aborts its simulation neither DDD
    nor HHH ever stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the
    simulation of its corresponding DDD as required by the design spec >>>>>>> that every partial halt decider must halt and is otherwise not any >>>>>>> kind of decider at all.
    Like Fred recognised a while ago, you are arguing as if HHH didn't >>>>>> abort.

    I am talking about hypothetical possible ways that HHH could be
    encoded.
    (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.
    Therefore (a) is correct and (b) is incorrect according to the
    design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not need to be
    aborted when simulated, because it already halts on its own.

    You must have attention deficit disorder.
    Please no ableism.
    (a) At least one HHH aborts.
    (b) No HHH ever aborts.
    Every X has property Y or not, there is no inbetween.

    Do you have difficulty reading and writing English?
    If every X has property Y or not, then it is clear that every HHH abort
    or not.

    If the first HHH waits on the second HHH and the second waits on the
    third... Then no HHH ever aborts.
    Yes, exactly. That's one half of the contradiction. The other half:
    When all of them abort, all of them are wrong to do so, because
    what they are simulating also aborts, making the abort unnecessary.

    --
    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)
  • From Richard Damon@21:1/5 to olcott on Mon Jul 22 20:01:00 2024
    On 7/22/24 11:08 AM, olcott wrote:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said:
    On 7/19/2024 3:51 AM, Mikko wrote:

    Anyway you did not say that some HHHᵢ can simulate the
    corresponding DDDᵢ to its termination. And each DDDᵢ does
    terminate, whether simulated or not.


    Then DDD correctly simulated by any pure function HHH cannot possibly >>>>> reach its own return instruction and halt, therefore every HHH is
    correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting
    comoputation as non-halting.
    In each of the above instances DDD never reaches its return instruction
    and halts. This proves that HHH is correct to report that its DDD never
    halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly emulated by its
    HHH and this HHH never aborts its simulation neither DDD nor HHH ever
    stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the simulation of >>> its corresponding DDD as required by the design spec that every partial
    halt decider must halt and is otherwise not any kind of decider at all.
    Like Fred recognised a while ago, you are arguing as if HHH didn't abort.

    That HHH is required to abort its simulation of DDD conclusively proves
    that this DDD never halts.
    You've got it the wrong way around.


    I am talking about hypothetical possible ways that HHH could be encoded.
    (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.

    Therefore (a) is correct and (b) is incorrect according to the
    design requirements for HHH that it must halt.

    It is also a truism that any input that must be aborted
    is a non-halting input.


    And since we can give the FULL input to a pure emulator (for any HHH
    that returns) and it will return shows that and DDD built on an HHH that INCORRECTLY decides its input is non-halting are returns was INCORRECT.

    It also shows that you are nothing but a pathological liar

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Tue Jul 23 10:24:32 2024
    Op 22.jul.2024 om 23:36 schreef olcott:
    On 7/22/2024 4:19 PM, joes wrote:
    Am Mon, 22 Jul 2024 14:57:21 -0500 schrieb olcott:
    On 7/22/2024 2:30 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 20:31 schreef olcott:
    On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said:
    On 7/19/2024 3:51 AM, Mikko wrote:

    Then DDD correctly simulated by any pure function HHH cannot >>>>>>>>>>> possibly reach its own return instruction and halt, therefore >>>>>>>>>>> every HHH is correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting >>>>>>>>>> comoputation as non-halting.
    In each of the above instances DDD never reaches its return
    instruction and halts. This proves that HHH is correct to report >>>>>>>>> that its DDD never halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly emulated >>>>>>>>> by its HHH and this HHH never aborts its simulation neither DDD >>>>>>>>> nor HHH ever stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the
    simulation of its corresponding DDD as required by the design spec >>>>>>>>> that every partial halt decider must halt and is otherwise not any >>>>>>>>> kind of decider at all.
    Like Fred recognised a while ago, you are arguing as if HHH didn't >>>>>>>> abort.

    I am talking about hypothetical possible ways that HHH could be
    encoded.
    (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.
    Therefore (a) is correct and (b) is incorrect according to the
    design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not need to be >>>>>> aborted when simulated, because it already halts on its own.

    You must have attention deficit disorder.
    Please no ableism.
    (a) At least one HHH aborts.
    (b) No HHH ever aborts.
    Every X has property Y or not, there is no inbetween.

    Do you have difficulty reading and writing English?
    If every X has property Y or not, then it is clear that every HHH abort >>>> or not.

    If the first HHH waits on the second HHH and the second waits on the
    third... Then no HHH ever aborts.
    Yes, exactly. That's one half of the contradiction. The other half:
    When all of them abort, all of them are wrong to do so, because
    what they are simulating also aborts, making the abort unnecessary.


    If no HHH ever aborts its simulation then no HHH ever halts.
    This proves that some HHH must abort its simulation and that
    its corresponding DDD specifies non-halting behavior.


    No, when it aborts its simulation, its simulation becomes incomplete
    and, therefore, incorrect. The simulated HHH would halt.
    When the HHH that does not abort is replaced with a HHH that aborts,
    also the behaviour of DDD is changed. The new DDD does halt and does not
    need to be aborted any more.

    You cannot say aborting results in a correct simulation, only because
    not aborting is worse.

    Not aborting is incorrect. Aborting is not correct either.

    The only behaviour specified by DDD is the behaviour of HHH, because DDD
    does nothing else that calling HHH.

    You are trying to hide the behaviour of HHH by introducing an unneeded DDD.

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

    This has the same problem. This proves that the problem is not in DDD,
    but in HHH, which halts when it aborts the simulation, but it decides
    that the simulation of itself does not halt.
    It shows that HHH cannot possibly simulate itself correctly.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Tue Jul 23 10:17:56 2024
    Op 22.jul.2024 om 21:57 schreef olcott:
    On 7/22/2024 2:30 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 20:31 schreef olcott:
    On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said:
    On 7/19/2024 3:51 AM, Mikko wrote:

    Anyway you did not say that some HHHᵢ can simulate the >>>>>>>>>>>> corresponding DDDᵢ to its termination. And each DDDᵢ does >>>>>>>>>>>> terminate, whether simulated or not.


    Then DDD correctly simulated by any pure function HHH cannot >>>>>>>>> possibly
    reach its own return instruction and halt, therefore every HHH is >>>>>>>>> correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting
    comoputation as non-halting.
    In each of the above instances DDD never reaches its return
    instruction
    and halts. This proves that HHH is correct to report that its DDD >>>>>>> never
    halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly emulated >>>>>>> by its
    HHH and this HHH never aborts its simulation neither DDD nor HHH >>>>>>> ever
    stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the
    simulation of
    its corresponding DDD as required by the design spec that every
    partial
    halt decider must halt and is otherwise not any kind of decider
    at all.
    Like Fred recognised a while ago, you are arguing as if HHH didn't >>>>>> abort.

    That HHH is required to abort its simulation of DDD conclusively >>>>>>> proves
    that this DDD never halts.
    You've got it the wrong way around.


    I am talking about hypothetical possible ways that HHH could be
    encoded.
    (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.

    Therefore (a) is correct and (b) is incorrect according to the
    design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not need to
    be aborted when simulated, because it already halts on its own.

    You must have attention deficit disorder.
    (a) At least one HHH aborts.
    (b) No HHH ever aborts.

    Every X has property Y or not, there is no inbetween.

    Do you have difficulty reading and writing English?

    If every X has property Y or not, then it is clear that every HHH
    abort or not.

    Sure and when we start a race with a single file line of
    people that are 15 feet apart and everyone goes the same
    speed then everyone will reach the finish line, eventually.

    When the first HHH that reaches the finish line stops
    simulating its input then no other HHH can possibly reach
    the finish line because nothing is simulating them.

    Exactly! That is the error in HHH. It stops simulating before the other
    HHH could reach the finish line. The simulated HHH and the simulating
    HHH have the same finish line, because both abort after N cycles.
    So, it is ncorrect to abort the simulated HHH, which would have reached
    the finish line on its own, if not aborted.


    If the first HHH waits on the second HHH and the second
    waits on the third... Then no HHH ever aborts.

    Excatly! That is why HHH cannot possibly simulate itself correctly. Do
    you finally get it?

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Tue Jul 23 18:46:09 2024
    Op 23.jul.2024 om 17:03 schreef olcott:
    On 7/23/2024 3:17 AM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 21:57 schreef olcott:
    On 7/22/2024 2:30 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 20:31 schreef olcott:
    On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said:
    On 7/19/2024 3:51 AM, Mikko wrote:

    Anyway you did not say that some HHHᵢ can simulate the >>>>>>>>>>>>>> corresponding DDDᵢ to its termination. And each DDDᵢ does >>>>>>>>>>>>>> terminate, whether simulated or not.


    Then DDD correctly simulated by any pure function HHH cannot >>>>>>>>>>> possibly
    reach its own return instruction and halt, therefore every >>>>>>>>>>> HHH is
    correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting >>>>>>>>>> comoputation as non-halting.
    In each of the above instances DDD never reaches its return
    instruction
    and halts. This proves that HHH is correct to report that its >>>>>>>>> DDD never
    halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly
    emulated by its
    HHH and this HHH never aborts its simulation neither DDD nor >>>>>>>>> HHH ever
    stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the
    simulation of
    its corresponding DDD as required by the design spec that every >>>>>>>>> partial
    halt decider must halt and is otherwise not any kind of decider >>>>>>>>> at all.
    Like Fred recognised a while ago, you are arguing as if HHH
    didn't abort.

    That HHH is required to abort its simulation of DDD
    conclusively proves
    that this DDD never halts.
    You've got it the wrong way around.


    I am talking about hypothetical possible ways that HHH could be
    encoded.
    (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.

    Therefore (a) is correct and (b) is incorrect according to the
    design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not need to >>>>>> be aborted when simulated, because it already halts on its own.

    You must have attention deficit disorder.
    (a) At least one HHH aborts.
    (b) No HHH ever aborts.

    Every X has property Y or not, there is no inbetween.

    Do you have difficulty reading and writing English?

    If every X has property Y or not, then it is clear that every HHH
    abort or not.

    Sure and when we start a race with a single file line of
    people that are 15 feet apart and everyone goes the same
    speed then everyone will reach the finish line, eventually.

    When the first HHH that reaches the finish line stops
    simulating its input then no other HHH can possibly reach
    the finish line because nothing is simulating them.

    Exactly! That is the error in HHH. It stops simulating before the
    other HHH could reach the finish line.

    So you don't even know how foot races work.

    The winner of the race is not supposed to wait
    so that everyone crosses the finish line at once.

    But do you know how foot races work? When the winner reaches the finish,
    the other players do not disappear. They do not halt either. They
    continue until they also reach the finish line.


    Also with HHH(DDD) there are infinite instances
    in the race. Waiting for the last one to finish
    waits forever. The first one to cross the finish
    line ends the race. Every other instance is
    immediately incapacitated
    You don't have to wait for the last one of an infinite number. It is
    sufficient to wait for the first simulated HHH, because that one aborts
    and halts and then all other instances disappear.
    That is the correct way, but HHH cannot do that.
    HHH cannot wait that long, because it is encoded to abort too soon.

    HHH cannot possibly simulate itself correctly!

    HHH decides that all other runners will run forever. Therefore, it
    thinks that it does not need to go all the way to the finish line. HHH
    stops running far before the finish line. That makes that it is not the
    winner.

    HHH cannot possibly simulate itself correctly!

    It is incorrect for a runner to think that the other runners will run
    forever. They all have the same finish line.
    Similarly, both the simulating HHH and the simulated HHH have the same
    finish line. Both will abort and halt after N cycles. None of them will
    run forever.
    So, when HHH aborts the simulation after N cycles, the simulated HHH has
    only one cycle to go. This makes the simulation incomplete and incorrect
    HHH cannot possibly simulate itself correctly. Your own trace that it
    cannot possibly reach the end of the simulated HHH.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Tue Jul 23 20:13:25 2024
    Op 23.jul.2024 om 19:54 schreef olcott:
    On 7/23/2024 11:46 AM, Fred. Zwarts wrote:
    Op 23.jul.2024 om 17:03 schreef olcott:
    On 7/23/2024 3:17 AM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 21:57 schreef olcott:
    On 7/22/2024 2:30 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 20:31 schreef olcott:
    On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said:
    On 7/19/2024 3:51 AM, Mikko wrote:

    Anyway you did not say that some HHHᵢ can simulate the >>>>>>>>>>>>>>>> corresponding DDDᵢ to its termination. And each DDDᵢ does >>>>>>>>>>>>>>>> terminate, whether simulated or not.


    Then DDD correctly simulated by any pure function HHH >>>>>>>>>>>>> cannot possibly
    reach its own return instruction and halt, therefore every >>>>>>>>>>>>> HHH is
    correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting >>>>>>>>>>>> comoputation as non-halting.
    In each of the above instances DDD never reaches its return >>>>>>>>>>> instruction
    and halts. This proves that HHH is correct to report that its >>>>>>>>>>> DDD never
    halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly
    emulated by its
    HHH and this HHH never aborts its simulation neither DDD nor >>>>>>>>>>> HHH ever
    stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the >>>>>>>>>>> simulation of
    its corresponding DDD as required by the design spec that >>>>>>>>>>> every partial
    halt decider must halt and is otherwise not any kind of
    decider at all.
    Like Fred recognised a while ago, you are arguing as if HHH >>>>>>>>>> didn't abort.

    That HHH is required to abort its simulation of DDD
    conclusively proves
    that this DDD never halts.
    You've got it the wrong way around.


    I am talking about hypothetical possible ways that HHH could be >>>>>>>>> encoded.
    (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.

    Therefore (a) is correct and (b) is incorrect according to the >>>>>>>>> design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not need >>>>>>>> to be aborted when simulated, because it already halts on its own. >>>>>>>
    You must have attention deficit disorder.
    (a) At least one HHH aborts.
    (b) No HHH ever aborts.

    Every X has property Y or not, there is no inbetween.

    Do you have difficulty reading and writing English?

    If every X has property Y or not, then it is clear that every HHH
    abort or not.

    Sure and when we start a race with a single file line of
    people that are 15 feet apart and everyone goes the same
    speed then everyone will reach the finish line, eventually.

    When the first HHH that reaches the finish line stops
    simulating its input then no other HHH can possibly reach
    the finish line because nothing is simulating them.

    Exactly! That is the error in HHH. It stops simulating before the
    other HHH could reach the finish line.

    So you don't even know how foot races work.

    The winner of the race is not supposed to wait
    so that everyone crosses the finish line at once.

    But do you know how foot races work? When the winner reaches the
    finish, the other players do not disappear. They do not halt either.
    They continue until they also reach the finish line.


    Also with HHH(DDD) there are infinite instances
    in the race. Waiting for the last one to finish
    waits forever. The first one to cross the finish
    line ends the race. Every other instance is
    immediately incapacitated
    You don't have to wait for the last one of an infinite number. It is
    sufficient to wait for the first simulated HHH, because that one
    aborts and halts

    Since HHH is the exact same machine code then when the first one waits
    for the second one the second one waits for the third on and on forever.


    Indeed! Exactly! You are almost at the finish.
    If HHH aborts after N cycles then only HHH that aborts after M cycles
    does a correct simulation, when M > N.
    No HHH can possibly simulate *itself* correctly. Other HHH *can* do a
    correct simulation when M > N.
    What HHH should do, is different from what it does, because that is how
    HHH is coded.
    When you change the code, also the requirement changes when it has to
    simulate *itself* correctly. No matter how far you increase N, it never
    reaches N+1. It always aborts one cycle too early when simulating itself.
    The HHH that aborts after N cycles can only simulate correctly the HHH
    that abort after K cycles when K < N. This shows that HHH cannot
    possibly simulate *itself* correctly.
    That there is no way to do it correctly, does not mean that there must
    be another way to do it correctly.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Tue Jul 23 20:55:16 2024
    Op 23.jul.2024 om 20:18 schreef olcott:
    On 7/23/2024 1:13 PM, Fred. Zwarts wrote:
    Op 23.jul.2024 om 19:54 schreef olcott:
    On 7/23/2024 11:46 AM, Fred. Zwarts wrote:
    Op 23.jul.2024 om 17:03 schreef olcott:
    On 7/23/2024 3:17 AM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 21:57 schreef olcott:
    On 7/22/2024 2:30 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 20:31 schreef olcott:
    On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott:
    On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said:
    On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said: >>>>>>>>>>>>>>>>>>> On 7/19/2024 3:51 AM, Mikko wrote:

    Anyway you did not say that some HHHᵢ can simulate the >>>>>>>>>>>>>>>>>> corresponding DDDᵢ to its termination. And each DDDᵢ does
    terminate, whether simulated or not.


    Then DDD correctly simulated by any pure function HHH >>>>>>>>>>>>>>> cannot possibly
    reach its own return instruction and halt, therefore >>>>>>>>>>>>>>> every HHH is
    correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a halting >>>>>>>>>>>>>> comoputation as non-halting.
    In each of the above instances DDD never reaches its return >>>>>>>>>>>>> instruction
    and halts. This proves that HHH is correct to report that >>>>>>>>>>>>> its DDD never
    halts.
    It can't return if the simulation of it is aborted.

    Within the hypothetical scenario where DDD is correctly >>>>>>>>>>>>> emulated by its
    HHH and this HHH never aborts its simulation neither DDD >>>>>>>>>>>>> nor HHH ever
    stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort the >>>>>>>>>>>>> simulation of
    its corresponding DDD as required by the design spec that >>>>>>>>>>>>> every partial
    halt decider must halt and is otherwise not any kind of >>>>>>>>>>>>> decider at all.
    Like Fred recognised a while ago, you are arguing as if HHH >>>>>>>>>>>> didn't abort.

    That HHH is required to abort its simulation of DDD
    conclusively proves
    that this DDD never halts.
    You've got it the wrong way around.


    I am talking about hypothetical possible ways that HHH could >>>>>>>>>>> be encoded.
    (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation.

    Therefore (a) is correct and (b) is incorrect according to the >>>>>>>>>>> design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not >>>>>>>>>> need to be aborted when simulated, because it already halts on >>>>>>>>>> its own.

    You must have attention deficit disorder.
    (a) At least one HHH aborts.
    (b) No HHH ever aborts.

    Every X has property Y or not, there is no inbetween.

    Do you have difficulty reading and writing English?

    If every X has property Y or not, then it is clear that every
    HHH abort or not.

    Sure and when we start a race with a single file line of
    people that are 15 feet apart and everyone goes the same
    speed then everyone will reach the finish line, eventually.

    When the first HHH that reaches the finish line stops
    simulating its input then no other HHH can possibly reach
    the finish line because nothing is simulating them.

    Exactly! That is the error in HHH. It stops simulating before the
    other HHH could reach the finish line.

    So you don't even know how foot races work.

    The winner of the race is not supposed to wait
    so that everyone crosses the finish line at once.

    But do you know how foot races work? When the winner reaches the
    finish, the other players do not disappear. They do not halt either.
    They continue until they also reach the finish line.


    Also with HHH(DDD) there are infinite instances
    in the race. Waiting for the last one to finish
    waits forever. The first one to cross the finish
    line ends the race. Every other instance is
    immediately incapacitated
    You don't have to wait for the last one of an infinite number. It is
    sufficient to wait for the first simulated HHH, because that one
    aborts and halts

    Since HHH is the exact same machine code then when the first one waits
    for the second one the second one waits for the third on and on forever. >>>

    Indeed! Exactly! You are almost at the finish.

    *THIS SEEMS PERMANENTLY TOO DIFFICULT FOR YOU TO UNDERSTAND*

    Irrelevant nonsense ignores, because olcott seems to have difficulties
    with reading and writing English.


    Unless the first one aborts none of them ever aborts and HHH
    itself never stops running. Therefore is is correct and necessary
    for the first HHH to abort.

    But then it fails at another point. When it aborts, it aborts too soon,
    before the simulated HHH, that also aborts, would halt.


    If HHH aborts after N cycles then only HHH that aborts after M cycles
    does a correct simulation, when M > N.
    No HHH can possibly simulate *itself* correctly. Other HHH *can* do a
    correct simulation when M > N.
    What HHH should do, is different from what it does, because that is
    how HHH is coded.
    When you change the code, also the requirement changes when it has to
    simulate *itself* correctly. No matter how far you increase N, it
    never reaches N+1. It always aborts one cycle too early when
    simulating itself.
    The HHH that aborts after N cycles can only simulate correctly the HHH
    that abort after K cycles when K < N. This shows that HHH cannot
    possibly simulate *itself* correctly.

    When N instructions of DDD are simulated according to the
    x86 semantics that they specify then N instructions of been
    simulated correctly.

    But when it aborts M instructions before the simulation would come to an
    end, the simulation is incomplete and, therefore, incorrect.


    When DDD specifies non-halting behavior then it is stupidly
    wrong to require a correct simulation to be a complete simulation.

    But when DDD would halt after N cycles, it is stupidly wrong to abort
    after N-1 cycles and claim that it would not halt.

    Your own words are:
    HHH is the exact same machine code
    Therefore, when the semantics of this x86 code specifies that the
    simulating HHH halts, it also specifies that the simulated HHH halts,
    because it is the exact same code.
    So, it is stupidly wrong to stop the simulation of this code and claim
    that it is non-halting.

    DDD is a misleading and unneeded complication. It is easy to eliminate DDD:

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

    This has the same problem. This proves that the problem is not in DDD,
    but in HHH, which halts when it aborts the simulation, but it decides
    that the simulation of itself does not halt.
    It shows that HHH cannot possibly simulate itself correctly.

    HHH is simply unable to decide about finite recursions.

    void Finite_Recursion (int N) {
    if (N > 0) Finite_Recursion (N - 1);
    }

    It decides after N recursions that there is an infinite recursion, which
    is incorrect.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Fred. Zwarts@21:1/5 to All on Wed Jul 24 11:00:56 2024
    Op 23.jul.2024 om 21:17 schreef olcott:
    On 7/23/2024 1:55 PM, Fred. Zwarts wrote:
    Op 23.jul.2024 om 20:18 schreef olcott:
    On 7/23/2024 1:13 PM, Fred. Zwarts wrote:
    Op 23.jul.2024 om 19:54 schreef olcott:
    On 7/23/2024 11:46 AM, Fred. Zwarts wrote:
    Op 23.jul.2024 om 17:03 schreef olcott:
    On 7/23/2024 3:17 AM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 21:57 schreef olcott:
    On 7/22/2024 2:30 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 20:31 schreef olcott:
    On 7/22/2024 12:45 PM, Fred. Zwarts wrote:
    Op 22.jul.2024 om 17:08 schreef olcott:
    On 7/22/2024 9:32 AM, joes wrote:
    Am Mon, 22 Jul 2024 09:13:33 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 7/22/2024 3:01 AM, Mikko wrote:
    On 2024-07-21 13:50:17 +0000, olcott said:
    On 7/21/2024 4:38 AM, Mikko wrote:
    On 2024-07-20 13:28:36 +0000, olcott said: >>>>>>>>>>>>>>>>>>> On 7/20/2024 3:54 AM, Mikko wrote:
    On 2024-07-19 14:39:25 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 7/19/2024 3:51 AM, Mikko wrote:

    Anyway you did not say that some HHHᵢ can simulate the >>>>>>>>>>>>>>>>>>>> corresponding DDDᵢ to its termination. And each DDDᵢ >>>>>>>>>>>>>>>>>>>> does
    terminate, whether simulated or not.


    Then DDD correctly simulated by any pure function HHH >>>>>>>>>>>>>>>>> cannot possibly
    reach its own return instruction and halt, therefore >>>>>>>>>>>>>>>>> every HHH is
    correct to reject its DDD as non-halting.
    That does not follow. It is never correct to reject a >>>>>>>>>>>>>>>> halting
    comoputation as non-halting.
    In each of the above instances DDD never reaches its >>>>>>>>>>>>>>> return instruction
    and halts. This proves that HHH is correct to report that >>>>>>>>>>>>>>> its DDD never
    halts.
    It can't return if the simulation of it is aborted. >>>>>>>>>>>>>>
    Within the hypothetical scenario where DDD is correctly >>>>>>>>>>>>>>> emulated by its
    HHH and this HHH never aborts its simulation neither DDD >>>>>>>>>>>>>>> nor HHH ever
    stops running.
    In actuality HHH DOES abort simulating.

    This conclusively proves that HHH is required to abort >>>>>>>>>>>>>>> the simulation of
    its corresponding DDD as required by the design spec that >>>>>>>>>>>>>>> every partial
    halt decider must halt and is otherwise not any kind of >>>>>>>>>>>>>>> decider at all.
    Like Fred recognised a while ago, you are arguing as if >>>>>>>>>>>>>> HHH didn't abort.

    That HHH is required to abort its simulation of DDD >>>>>>>>>>>>>>> conclusively proves
    that this DDD never halts.
    You've got it the wrong way around.


    I am talking about hypothetical possible ways that HHH >>>>>>>>>>>>> could be encoded.
    (a) HHH(DDD) is encoded to abort its simulation.
    (b) HHH(DDD) is encoded to never abort its simulation. >>>>>>>>>>>>>
    Therefore (a) is correct and (b) is incorrect according to the >>>>>>>>>>>>> design requirements for HHH that it must halt.

    Both are incorrect. An HHH, when encoded to abort does not >>>>>>>>>>>> need to be aborted when simulated, because it already halts >>>>>>>>>>>> on its own.

    You must have attention deficit disorder.
    (a) At least one HHH aborts.
    (b) No HHH ever aborts.

    Every X has property Y or not, there is no inbetween.

    Do you have difficulty reading and writing English?

    If every X has property Y or not, then it is clear that every >>>>>>>>>> HHH abort or not.

    Sure and when we start a race with a single file line of
    people that are 15 feet apart and everyone goes the same
    speed then everyone will reach the finish line, eventually.

    When the first HHH that reaches the finish line stops
    simulating its input then no other HHH can possibly reach
    the finish line because nothing is simulating them.

    Exactly! That is the error in HHH. It stops simulating before
    the other HHH could reach the finish line.

    So you don't even know how foot races work.

    The winner of the race is not supposed to wait
    so that everyone crosses the finish line at once.

    But do you know how foot races work? When the winner reaches the
    finish, the other players do not disappear. They do not halt
    either. They continue until they also reach the finish line.


    Also with HHH(DDD) there are infinite instances
    in the race. Waiting for the last one to finish
    waits forever. The first one to cross the finish
    line ends the race. Every other instance is
    immediately incapacitated
    You don't have to wait for the last one of an infinite number. It
    is sufficient to wait for the first simulated HHH, because that
    one aborts and halts

    Since HHH is the exact same machine code then when the first one waits >>>>> for the second one the second one waits for the third on and on
    forever.


    Indeed! Exactly! You are almost at the finish.

    *THIS SEEMS PERMANENTLY TOO DIFFICULT FOR YOU TO UNDERSTAND*

    Irrelevant nonsense ignores, because olcott seems to have difficulties
    with reading and writing English.


    Unless the first one aborts none of them ever aborts and HHH
    itself never stops running. Therefore is is correct and necessary
    for the first HHH to abort.

    But then it fails at another point. When it aborts, it aborts too soon,

    *This is just over your head no sense continuing the dialogue*

    Irrelevant nonsense ignored.

    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT
    Unless the first one aborts NONE OF THEM EVER ABORT


    So, you prove that HHH cannot possibly simulate itself correctly.

    When HHH does not abort, it needs a simulator that aborts, but when it simulates itself that is not the case, so the simulation is wrong.

    When HHH aborts, it needs a simulator that does not abort, which is not
    the case when it simulates itself, so the simulation is also wrong.

    Both aborting an non-aborting HHH variants are unable to simulate their
    own x86 code correctly.

    It is a pity that you cannot even see such simple fact.

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