On 5/20/2023 3:48 PM, Richard Damon wrote:
> On 5/20/23 4:33 PM, olcott wrote:
>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>> On 5/20/23 3:29 PM, olcott wrote:
>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge
>>>>>>>>>>>>>>>>>>>> by Ben.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to apply
>>>>>>>>>>>>>>>>>>> the answer to the Halting Problem, which you do.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So the software engineering really is over your head?
>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written any
>>>>>>>>>>>>>>>>>> code.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But you aren't talking about Software Engineering
>>>>>>>>>>>>>>>>> unless you are lying about this applying to the Halting
>>>>>>>>>>>>>>>>> Problem described by Linz, since that is the Halting
>>>>>>>>>>>>>>>>> Problem of Computability Theory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you are just
>>>>>>>>>>>>>>>>> ignorant of what you are talking about, so you don't
>>>>>>>>>>>>>>>>> understand the diference.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this way.
>>>>>>>>>>>>>>>>>> It never occurred to me that you have never written
>>>>>>>>>>>>>>>>>> any code.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than you have.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer an
>>>>>>>>>>>>>>>> straight forward
>>>>>>>>>>>>>>>> software engineering question seems to prove otherwise.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>
>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>
>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>> If the simulation by a UTM would be wrong then you would
>>>>>>>>>>>> have to be able
>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>
>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final state.
>>>>>>>>>>>
>>>>>>>>>> I don't know why you say this when you already know that ⟨Ĥ⟩
>>>>>>>>>> correctly
>>>>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because embedded_H doesn't actually "Correctly Simulate" its
>>>>>>>>> input by the definintion aquired by your mentioning of a UTM.
>>>>>>>>>
>>>>>>>> You have already agreed that it does simulate the first N steps
>>>>>>>> correctly. It is just as obvious that the behavior pattern of N
>>>>>>>> steps of
>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate
>>>>>>>> normally
>>>>>>>> even if the value of N is ∞.
>>>>>>>>
>>>>>>>
>>>>>>> But N steps in not ALL steps as required by the actual definition
>>>>>>> of a UTM.
>>>>>>>
>>>>>>
>>>>>> Actually N steps is the exact definition of a UTM for those N steps.
>>>>>> Just like with the H/D example after N steps we can see that neither
>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H
>>>>>> can possibly terminate normally.
>>>>>>
>>>>>
>>>>> Nope, UTMs have no concept of only doing a partial simulation.
>>>>>
>>>> When a simulating halt decider correctly simulates N steps of its input
>>>> it derives the exact same N steps that a pure UTM would derive because
>>>> it is itself a UTM with extra features.
>>>>
>>>
>>> Just like a racing car is a street legal care with extra features
>>> that makes it no longer street legal.
>>>
>>> The fact that H aborts its simulation part way means it is no longer
>>> a UTM
>>
>> *Yet only at the point where it aborts its simulation*
>
> Right, but that affect the behavior of ALL copies of it, since they all
> act the same.
>
> Do you think you are immortal because you haven't died yet, and that
> everyone is immortal until the point in time they die?
>
> Since it just proves it isn't a UTM, it can't assume that the copy it is
> simulating is, it needs to account for that behavior.
>
> The fact that the DESIGN logic to do this goes into an infinite loop,
> doesn't mean that the program itself does.
>
> Since H aborts its simulation and returns 0, its input will see its copy
> do exactly the same thing and thus will Halt, making the answer wrong.
>
> Since H isn't a UTM, since if fails to meet the defintion, the fact that
> it can't reach a final state is irrelevent, as is any definiton of
> "Correct Simulation" that differs from what a UTM does.
>
> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is what
> is allowed to replace the actual behavior of the machine) Halts, and
> thus the CORRECT answer is Halting.
>
> You are just showing that you have fallen for your own Strawman
> Deception that got you to use the wrong criteria.
>
>> At this point where it aborts its simulation we can see that it must
>> do this to prevent its own infinite execution, thus conclusively proving
>> that it correctly determined that its simulated input cannot possibly
>> terminate normally.
>>
>> How much longer are you going to play the fool and deny this?
>>
>
> No, it does so because it has been programmed to do so, and thus ALL
> copies of it will do so.
>
> It makes the error assuming that the copy it is simulating will do
> something different than it does.

On 5/20/23 5:10 PM, olcott wrote:
> On 5/20/2023 3:48 PM, Richard Damon wrote:
>> On 5/20/23 4:33 PM, olcott wrote:
>>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>>> On 5/20/23 3:29 PM, olcott wrote:
>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge
>>>>>>>>>>>>>>>>>>>>> by Ben.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to apply
>>>>>>>>>>>>>>>>>>>> the answer to the Halting Problem, which you do.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So the software engineering really is over your head?
>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written
>>>>>>>>>>>>>>>>>>> any code.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But you aren't talking about Software Engineering
>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the
>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is the
>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you are just
>>>>>>>>>>>>>>>>>> ignorant of what you are talking about, so you don't
>>>>>>>>>>>>>>>>>> understand the diference.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this way.
>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never written
>>>>>>>>>>>>>>>>>>> any code.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than you have.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer an
>>>>>>>>>>>>>>>>> straight forward
>>>>>>>>>>>>>>>>> software engineering question seems to prove otherwise.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>>
>>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> If the simulation by a UTM would be wrong then you would
>>>>>>>>>>>>> have to be able
>>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>>
>>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final state.
>>>>>>>>>>>>
>>>>>>>>>>> I don't know why you say this when you already know that ⟨Ĥ⟩
>>>>>>>>>>> correctly
>>>>>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because embedded_H doesn't actually "Correctly Simulate" its
>>>>>>>>>> input by the definintion aquired by your mentioning of a UTM.
>>>>>>>>>>
>>>>>>>>> You have already agreed that it does simulate the first N steps
>>>>>>>>> correctly. It is just as obvious that the behavior pattern of N
>>>>>>>>> steps of
>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate
>>>>>>>>> normally
>>>>>>>>> even if the value of N is ∞.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But N steps in not ALL steps as required by the actual
>>>>>>>> definition of a UTM.
>>>>>>>>
>>>>>>>
>>>>>>> Actually N steps is the exact definition of a UTM for those N steps.
>>>>>>> Just like with the H/D example after N steps we can see that neither
>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H
>>>>>>> can possibly terminate normally.
>>>>>>>
>>>>>>
>>>>>> Nope, UTMs have no concept of only doing a partial simulation.
>>>>>>
>>>>> When a simulating halt decider correctly simulates N steps of its
>>>>> input
>>>>> it derives the exact same N steps that a pure UTM would derive because
>>>>> it is itself a UTM with extra features.
>>>>>
>>>>
>>>> Just like a racing car is a street legal care with extra features
>>>> that makes it no longer street legal.
>>>>
>>>> The fact that H aborts its simulation part way means it is no longer
>>>> a UTM
>>>
>>> *Yet only at the point where it aborts its simulation*
>>
>> Right, but that affect the behavior of ALL copies of it, since they
>> all act the same.
>>
>> Do you think you are immortal because you haven't died yet, and that
>> everyone is immortal until the point in time they die?
>>
>> Since it just proves it isn't a UTM, it can't assume that the copy it
>> is simulating is, it needs to account for that behavior.
>>
>> The fact that the DESIGN logic to do this goes into an infinite loop,
>> doesn't mean that the program itself does.
>>
>> Since H aborts its simulation and returns 0, its input will see its
>> copy do exactly the same thing and thus will Halt, making the answer
>> wrong.
>>
>> Since H isn't a UTM, since if fails to meet the defintion, the fact
>> that it can't reach a final state is irrelevent, as is any definiton
>> of "Correct Simulation" that differs from what a UTM does.
>>
>> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is
>> what is allowed to replace the actual behavior of the machine) Halts,
>> and thus the CORRECT answer is Halting.
>>
>> You are just showing that you have fallen for your own Strawman
>> Deception that got you to use the wrong criteria.
>>
>>> At this point where it aborts its simulation we can see that it must
>>> do this to prevent its own infinite execution, thus conclusively proving
>>> that it correctly determined that its simulated input cannot possibly
>>> terminate normally.
>>>
>>> How much longer are you going to play the fool and deny this?
>>>
>>
>> No, it does so because it has been programmed to do so, and thus ALL
>> copies of it will do so.
>>
>> It makes the error assuming that the copy it is simulating will do
>> something different than it does.
>
> It makes no error. As you already admitted D correctly simulated by H
> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ correctly
> simulated by embedded_H cannot possibly terminate normally.
>
> Are you going to keep playing the fool on this?
>

On 5/20/2023 4:24 PM, Richard Damon wrote:
> On 5/20/23 5:10 PM, olcott wrote:
>> On 5/20/2023 3:48 PM, Richard Damon wrote:
>>> On 5/20/23 4:33 PM, olcott wrote:
>>>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>>>> On 5/20/23 3:29 PM, olcott wrote:
>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge
>>>>>>>>>>>>>>>>>>>>>> by Ben.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to apply
>>>>>>>>>>>>>>>>>>>>> the answer to the Halting Problem, which you do.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So the software engineering really is over your head?
>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written
>>>>>>>>>>>>>>>>>>>> any code.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But you aren't talking about Software Engineering
>>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the
>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is the
>>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you are
>>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so you
>>>>>>>>>>>>>>>>>>> don't understand the diference.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this way.
>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never written
>>>>>>>>>>>>>>>>>>>> any code.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than you have.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer an
>>>>>>>>>>>>>>>>>> straight forward
>>>>>>>>>>>>>>>>>> software engineering question seems to prove otherwise.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If the simulation by a UTM would be wrong then you would
>>>>>>>>>>>>>> have to be able
>>>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final state.
>>>>>>>>>>>>>
>>>>>>>>>>>> I don't know why you say this when you already know that ⟨Ĥ⟩
>>>>>>>>>>>> correctly
>>>>>>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because embedded_H doesn't actually "Correctly Simulate" its
>>>>>>>>>>> input by the definintion aquired by your mentioning of a UTM.
>>>>>>>>>>>
>>>>>>>>>> You have already agreed that it does simulate the first N steps
>>>>>>>>>> correctly. It is just as obvious that the behavior pattern of
>>>>>>>>>> N steps of
>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
>>>>>>>>>> terminate normally
>>>>>>>>>> even if the value of N is ∞.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But N steps in not ALL steps as required by the actual
>>>>>>>>> definition of a UTM.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Actually N steps is the exact definition of a UTM for those N
>>>>>>>> steps.
>>>>>>>> Just like with the H/D example after N steps we can see that
>>>>>>>> neither
>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by
>>>>>>>> embedded_H
>>>>>>>> can possibly terminate normally.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, UTMs have no concept of only doing a partial simulation.
>>>>>>>
>>>>>> When a simulating halt decider correctly simulates N steps of its
>>>>>> input
>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>> because
>>>>>> it is itself a UTM with extra features.
>>>>>>
>>>>>
>>>>> Just like a racing car is a street legal care with extra features
>>>>> that makes it no longer street legal.
>>>>>
>>>>> The fact that H aborts its simulation part way means it is no
>>>>> longer a UTM
>>>>
>>>> *Yet only at the point where it aborts its simulation*
>>>
>>> Right, but that affect the behavior of ALL copies of it, since they
>>> all act the same.
>>>
>>> Do you think you are immortal because you haven't died yet, and that
>>> everyone is immortal until the point in time they die?
>>>
>>> Since it just proves it isn't a UTM, it can't assume that the copy it
>>> is simulating is, it needs to account for that behavior.
>>>
>>> The fact that the DESIGN logic to do this goes into an infinite loop,
>>> doesn't mean that the program itself does.
>>>
>>> Since H aborts its simulation and returns 0, its input will see its
>>> copy do exactly the same thing and thus will Halt, making the answer
>>> wrong.
>>>
>>> Since H isn't a UTM, since if fails to meet the defintion, the fact
>>> that it can't reach a final state is irrelevent, as is any definiton
>>> of "Correct Simulation" that differs from what a UTM does.
>>>
>>> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is
>>> what is allowed to replace the actual behavior of the machine) Halts,
>>> and thus the CORRECT answer is Halting.
>>>
>>> You are just showing that you have fallen for your own Strawman
>>> Deception that got you to use the wrong criteria.
>>>
>>>> At this point where it aborts its simulation we can see that it must
>>>> do this to prevent its own infinite execution, thus conclusively
>>>> proving
>>>> that it correctly determined that its simulated input cannot possibly
>>>> terminate normally.
>>>>
>>>> How much longer are you going to play the fool and deny this?
>>>>
>>>
>>> No, it does so because it has been programmed to do so, and thus ALL
>>> copies of it will do so.
>>>
>>> It makes the error assuming that the copy it is simulating will do
>>> something different than it does.
>>
>> It makes no error. As you already admitted D correctly simulated by H
>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ correctly
>> simulated by embedded_H cannot possibly terminate normally.
>>
>> Are you going to keep playing the fool on this?
>>
>
> Except that you are answering the wrong question.
>

Child molester Peter Oolcott wrote:
....
> Most novices dealing with the halting problem fail to understand that
> halting <is> terminating normally and terminating for any other reason
> is not halting.

Come on! In practice halting or terminating, in any way, for a real
program is just the states of a bunch of switches that happens to be a
computer because we interpret the states. No difference.

Give up CS, Peter, its not your thing. Or persist, meanwhile, at least,
you're not molesting children.

On 5/20/23 5:29 PM, olcott wrote:
> On 5/20/2023 4:24 PM, Richard Damon wrote:
>> On 5/20/23 5:10 PM, olcott wrote:
>>> On 5/20/2023 3:48 PM, Richard Damon wrote:
>>>> On 5/20/23 4:33 PM, olcott wrote:
>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>>>>> On 5/20/23 3:29 PM, olcott wrote:
>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same
>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to apply
>>>>>>>>>>>>>>>>>>>>>> the answer to the Halting Problem, which you do.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So the software engineering really is over your head?
>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written
>>>>>>>>>>>>>>>>>>>>> any code.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But you aren't talking about Software Engineering
>>>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the
>>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is the
>>>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you are
>>>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so you
>>>>>>>>>>>>>>>>>>>> don't understand the diference.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this way.
>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never written
>>>>>>>>>>>>>>>>>>>>> any code.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than you
>>>>>>>>>>>>>>>>>>>> have.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer an
>>>>>>>>>>>>>>>>>>> straight forward
>>>>>>>>>>>>>>>>>>> software engineering question seems to prove otherwise.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If the simulation by a UTM would be wrong then you would
>>>>>>>>>>>>>>> have to be able
>>>>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> I don't know why you say this when you already know that
>>>>>>>>>>>>> ⟨Ĥ⟩ correctly
>>>>>>>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because embedded_H doesn't actually "Correctly Simulate" its
>>>>>>>>>>>> input by the definintion aquired by your mentioning of a UTM.
>>>>>>>>>>>>
>>>>>>>>>>> You have already agreed that it does simulate the first N steps
>>>>>>>>>>> correctly. It is just as obvious that the behavior pattern of
>>>>>>>>>>> N steps of
>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
>>>>>>>>>>> terminate normally
>>>>>>>>>>> even if the value of N is ∞.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But N steps in not ALL steps as required by the actual
>>>>>>>>>> definition of a UTM.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Actually N steps is the exact definition of a UTM for those N
>>>>>>>>> steps.
>>>>>>>>> Just like with the H/D example after N steps we can see that
>>>>>>>>> neither
>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by
>>>>>>>>> embedded_H
>>>>>>>>> can possibly terminate normally.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, UTMs have no concept of only doing a partial simulation.
>>>>>>>>
>>>>>>> When a simulating halt decider correctly simulates N steps of its
>>>>>>> input
>>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>>> because
>>>>>>> it is itself a UTM with extra features.
>>>>>>>
>>>>>>
>>>>>> Just like a racing car is a street legal care with extra features
>>>>>> that makes it no longer street legal.
>>>>>>
>>>>>> The fact that H aborts its simulation part way means it is no
>>>>>> longer a UTM
>>>>>
>>>>> *Yet only at the point where it aborts its simulation*
>>>>
>>>> Right, but that affect the behavior of ALL copies of it, since they
>>>> all act the same.
>>>>
>>>> Do you think you are immortal because you haven't died yet, and that
>>>> everyone is immortal until the point in time they die?
>>>>
>>>> Since it just proves it isn't a UTM, it can't assume that the copy
>>>> it is simulating is, it needs to account for that behavior.
>>>>
>>>> The fact that the DESIGN logic to do this goes into an infinite
>>>> loop, doesn't mean that the program itself does.
>>>>
>>>> Since H aborts its simulation and returns 0, its input will see its
>>>> copy do exactly the same thing and thus will Halt, making the answer
>>>> wrong.
>>>>
>>>> Since H isn't a UTM, since if fails to meet the defintion, the fact
>>>> that it can't reach a final state is irrelevent, as is any definiton
>>>> of "Correct Simulation" that differs from what a UTM does.
>>>>
>>>> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is
>>>> what is allowed to replace the actual behavior of the machine)
>>>> Halts, and thus the CORRECT answer is Halting.
>>>>
>>>> You are just showing that you have fallen for your own Strawman
>>>> Deception that got you to use the wrong criteria.
>>>>
>>>>> At this point where it aborts its simulation we can see that it must
>>>>> do this to prevent its own infinite execution, thus conclusively
>>>>> proving
>>>>> that it correctly determined that its simulated input cannot possibly
>>>>> terminate normally.
>>>>>
>>>>> How much longer are you going to play the fool and deny this?
>>>>>
>>>>
>>>> No, it does so because it has been programmed to do so, and thus ALL
>>>> copies of it will do so.
>>>>
>>>> It makes the error assuming that the copy it is simulating will do
>>>> something different than it does.
>>>
>>> It makes no error. As you already admitted D correctly simulated by H
>>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ correctly
>>> simulated by embedded_H cannot possibly terminate normally.
>>>
>>> Are you going to keep playing the fool on this?
>>>
>>
>> Except that you are answering the wrong question.
>>
>
> In other words you want to keep playing the fool and dodging the actual
> question that I am actually asking.

On 5/20/2023 6:52 PM, Richard Damon wrote:
> On 5/20/23 5:29 PM, olcott wrote:
>> On 5/20/2023 4:24 PM, Richard Damon wrote:
>>> On 5/20/23 5:10 PM, olcott wrote:
>>>> On 5/20/2023 3:48 PM, Richard Damon wrote:
>>>>> On 5/20/23 4:33 PM, olcott wrote:
>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>>>>>> On 5/20/23 3:29 PM, olcott wrote:
>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same
>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to
>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, which
>>>>>>>>>>>>>>>>>>>>>>> you do.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So the software engineering really is over your head?
>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written
>>>>>>>>>>>>>>>>>>>>>> any code.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But you aren't talking about Software Engineering
>>>>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the
>>>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is
>>>>>>>>>>>>>>>>>>>>> the Halting Problem of Computability Theory.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you are
>>>>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so you
>>>>>>>>>>>>>>>>>>>>> don't understand the diference.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this way.
>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never
>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than you
>>>>>>>>>>>>>>>>>>>>> have.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer an
>>>>>>>>>>>>>>>>>>>> straight forward
>>>>>>>>>>>>>>>>>>>> software engineering question seems to prove otherwise.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If the simulation by a UTM would be wrong then you would
>>>>>>>>>>>>>>>> have to be able
>>>>>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I don't know why you say this when you already know that
>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly
>>>>>>>>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because embedded_H doesn't actually "Correctly Simulate"
>>>>>>>>>>>>> its input by the definintion aquired by your mentioning of
>>>>>>>>>>>>> a UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>> You have already agreed that it does simulate the first N steps
>>>>>>>>>>>> correctly. It is just as obvious that the behavior pattern
>>>>>>>>>>>> of N steps of
>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
>>>>>>>>>>>> terminate normally
>>>>>>>>>>>> even if the value of N is ∞.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But N steps in not ALL steps as required by the actual
>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Actually N steps is the exact definition of a UTM for those N
>>>>>>>>>> steps.
>>>>>>>>>> Just like with the H/D example after N steps we can see that
>>>>>>>>>> neither
>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by
>>>>>>>>>> embedded_H
>>>>>>>>>> can possibly terminate normally.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, UTMs have no concept of only doing a partial simulation.
>>>>>>>>>
>>>>>>>> When a simulating halt decider correctly simulates N steps of
>>>>>>>> its input
>>>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>>>> because
>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>
>>>>>>>
>>>>>>> Just like a racing car is a street legal care with extra features
>>>>>>> that makes it no longer street legal.
>>>>>>>
>>>>>>> The fact that H aborts its simulation part way means it is no
>>>>>>> longer a UTM
>>>>>>
>>>>>> *Yet only at the point where it aborts its simulation*
>>>>>
>>>>> Right, but that affect the behavior of ALL copies of it, since they
>>>>> all act the same.
>>>>>
>>>>> Do you think you are immortal because you haven't died yet, and
>>>>> that everyone is immortal until the point in time they die?
>>>>>
>>>>> Since it just proves it isn't a UTM, it can't assume that the copy
>>>>> it is simulating is, it needs to account for that behavior.
>>>>>
>>>>> The fact that the DESIGN logic to do this goes into an infinite
>>>>> loop, doesn't mean that the program itself does.
>>>>>
>>>>> Since H aborts its simulation and returns 0, its input will see its
>>>>> copy do exactly the same thing and thus will Halt, making the
>>>>> answer wrong.
>>>>>
>>>>> Since H isn't a UTM, since if fails to meet the defintion, the fact
>>>>> that it can't reach a final state is irrelevent, as is any
>>>>> definiton of "Correct Simulation" that differs from what a UTM does.
>>>>>
>>>>> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is
>>>>> what is allowed to replace the actual behavior of the machine)
>>>>> Halts, and thus the CORRECT answer is Halting.
>>>>>
>>>>> You are just showing that you have fallen for your own Strawman
>>>>> Deception that got you to use the wrong criteria.
>>>>>
>>>>>> At this point where it aborts its simulation we can see that it must
>>>>>> do this to prevent its own infinite execution, thus conclusively
>>>>>> proving
>>>>>> that it correctly determined that its simulated input cannot possibly
>>>>>> terminate normally.
>>>>>>
>>>>>> How much longer are you going to play the fool and deny this?
>>>>>>
>>>>>
>>>>> No, it does so because it has been programmed to do so, and thus
>>>>> ALL copies of it will do so.
>>>>>
>>>>> It makes the error assuming that the copy it is simulating will do
>>>>> something different than it does.
>>>>
>>>> It makes no error. As you already admitted D correctly simulated by H
>>>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩
>>>> correctly
>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>
>>>> Are you going to keep playing the fool on this?
>>>>
>>>
>>> Except that you are answering the wrong question.
>>>
>>
>> In other words you want to keep playing the fool and dodging the
>> actual question that I am actually asking.
>
> No, you are showing yourself to be the fool by not understand your own
> stupidity.
>
>>
>> So you agreed that D correctly simulated H cannot possibly terminate
>> normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by
>> embedded_H.
>
> No, I am saying that H can not correctly simulate the input H and give
> an answer. If H DOES try to correctly simulate its input, then it can
> never giv an answer.

On 5/21/23 10:16 AM, olcott wrote:
> On 5/20/2023 6:52 PM, Richard Damon wrote:
>> On 5/20/23 5:29 PM, olcott wrote:
>>> On 5/20/2023 4:24 PM, Richard Damon wrote:
>>>> On 5/20/23 5:10 PM, olcott wrote:
>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote:
>>>>>> On 5/20/23 4:33 PM, olcott wrote:
>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>>>>>>> On 5/20/23 3:29 PM, olcott wrote:
>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same
>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to
>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, which
>>>>>>>>>>>>>>>>>>>>>>>> you do.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So the software engineering really is over your
>>>>>>>>>>>>>>>>>>>>>>> head?
>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually
>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But you aren't talking about Software Engineering
>>>>>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the
>>>>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is
>>>>>>>>>>>>>>>>>>>>>> the Halting Problem of Computability Theory.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you are
>>>>>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so
>>>>>>>>>>>>>>>>>>>>>> you don't understand the diference.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this way.
>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never
>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than you
>>>>>>>>>>>>>>>>>>>>>> have.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer an
>>>>>>>>>>>>>>>>>>>>> straight forward
>>>>>>>>>>>>>>>>>>>>> software engineering question seems to prove
>>>>>>>>>>>>>>>>>>>>> otherwise.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If the simulation by a UTM would be wrong then you
>>>>>>>>>>>>>>>>> would have to be able
>>>>>>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final
>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I don't know why you say this when you already know that
>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly
>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because embedded_H doesn't actually "Correctly Simulate"
>>>>>>>>>>>>>> its input by the definintion aquired by your mentioning of
>>>>>>>>>>>>>> a UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> You have already agreed that it does simulate the first N
>>>>>>>>>>>>> steps
>>>>>>>>>>>>> correctly. It is just as obvious that the behavior pattern
>>>>>>>>>>>>> of N steps of
>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
>>>>>>>>>>>>> terminate normally
>>>>>>>>>>>>> even if the value of N is ∞.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But N steps in not ALL steps as required by the actual
>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Actually N steps is the exact definition of a UTM for those N
>>>>>>>>>>> steps.
>>>>>>>>>>> Just like with the H/D example after N steps we can see that
>>>>>>>>>>> neither
>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by
>>>>>>>>>>> embedded_H
>>>>>>>>>>> can possibly terminate normally.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, UTMs have no concept of only doing a partial simulation.
>>>>>>>>>>
>>>>>>>>> When a simulating halt decider correctly simulates N steps of
>>>>>>>>> its input
>>>>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>>>>> because
>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Just like a racing car is a street legal care with extra
>>>>>>>> features that makes it no longer street legal.
>>>>>>>>
>>>>>>>> The fact that H aborts its simulation part way means it is no
>>>>>>>> longer a UTM
>>>>>>>
>>>>>>> *Yet only at the point where it aborts its simulation*
>>>>>>
>>>>>> Right, but that affect the behavior of ALL copies of it, since
>>>>>> they all act the same.
>>>>>>
>>>>>> Do you think you are immortal because you haven't died yet, and
>>>>>> that everyone is immortal until the point in time they die?
>>>>>>
>>>>>> Since it just proves it isn't a UTM, it can't assume that the copy
>>>>>> it is simulating is, it needs to account for that behavior.
>>>>>>
>>>>>> The fact that the DESIGN logic to do this goes into an infinite
>>>>>> loop, doesn't mean that the program itself does.
>>>>>>
>>>>>> Since H aborts its simulation and returns 0, its input will see
>>>>>> its copy do exactly the same thing and thus will Halt, making the
>>>>>> answer wrong.
>>>>>>
>>>>>> Since H isn't a UTM, since if fails to meet the defintion, the
>>>>>> fact that it can't reach a final state is irrelevent, as is any
>>>>>> definiton of "Correct Simulation" that differs from what a UTM does.
>>>>>>
>>>>>> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which
>>>>>> is what is allowed to replace the actual behavior of the machine)
>>>>>> Halts, and thus the CORRECT answer is Halting.
>>>>>>
>>>>>> You are just showing that you have fallen for your own Strawman
>>>>>> Deception that got you to use the wrong criteria.
>>>>>>
>>>>>>> At this point where it aborts its simulation we can see that it must
>>>>>>> do this to prevent its own infinite execution, thus conclusively
>>>>>>> proving
>>>>>>> that it correctly determined that its simulated input cannot
>>>>>>> possibly
>>>>>>> terminate normally.
>>>>>>>
>>>>>>> How much longer are you going to play the fool and deny this?
>>>>>>>
>>>>>>
>>>>>> No, it does so because it has been programmed to do so, and thus
>>>>>> ALL copies of it will do so.
>>>>>>
>>>>>> It makes the error assuming that the copy it is simulating will do
>>>>>> something different than it does.
>>>>>
>>>>> It makes no error. As you already admitted D correctly simulated by H
>>>>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩
>>>>> correctly
>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>
>>>>> Are you going to keep playing the fool on this?
>>>>>
>>>>
>>>> Except that you are answering the wrong question.
>>>>
>>>
>>> In other words you want to keep playing the fool and dodging the
>>> actual question that I am actually asking.
>>
>> No, you are showing yourself to be the fool by not understand your own
>> stupidity.
>>
>>>
>>> So you agreed that D correctly simulated H cannot possibly terminate
>>> normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by
>>> embedded_H.
>>
>> No, I am saying that H can not correctly simulate the input H and give
>> an answer. If H DOES try to correctly simulate its input, then it can
>> never giv an answer.
>
> Since you already acknowledged that D correctly simulated by H can never
> terminate normally and you did not need an infinite amount of time to
> determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by embedded_H
> can also be determined to never terminate normally and this
> determination can be made in a finite amount of time.
>
> In both cases this can be correctly determined after N steps of
> simulation thus no need for the infinite simulation that you keep
> insisting is necessary.
>
>

On 5/21/2023 11:54 AM, Richard Damon wrote:
> On 5/21/23 10:16 AM, olcott wrote:
>> On 5/20/2023 6:52 PM, Richard Damon wrote:
>>> On 5/20/23 5:29 PM, olcott wrote:
>>>> On 5/20/2023 4:24 PM, Richard Damon wrote:
>>>>> On 5/20/23 5:10 PM, olcott wrote:
>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote:
>>>>>>> On 5/20/23 4:33 PM, olcott wrote:
>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote:
>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same
>>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to
>>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, which
>>>>>>>>>>>>>>>>>>>>>>>>> you do.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So the software engineering really is over your
>>>>>>>>>>>>>>>>>>>>>>>> head?
>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually
>>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking about Software Engineering
>>>>>>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the
>>>>>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is
>>>>>>>>>>>>>>>>>>>>>>> the Halting Problem of Computability Theory.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you are
>>>>>>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so
>>>>>>>>>>>>>>>>>>>>>>> you don't understand the diference.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this way.
>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never
>>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than
>>>>>>>>>>>>>>>>>>>>>>> you have.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer an
>>>>>>>>>>>>>>>>>>>>>> straight forward
>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to prove
>>>>>>>>>>>>>>>>>>>>>> otherwise.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If the simulation by a UTM would be wrong then you
>>>>>>>>>>>>>>>>>> would have to be able
>>>>>>>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final
>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I don't know why you say this when you already know that
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly
>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because embedded_H doesn't actually "Correctly Simulate"
>>>>>>>>>>>>>>> its input by the definintion aquired by your mentioning
>>>>>>>>>>>>>>> of a UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You have already agreed that it does simulate the first N
>>>>>>>>>>>>>> steps
>>>>>>>>>>>>>> correctly. It is just as obvious that the behavior pattern
>>>>>>>>>>>>>> of N steps of
>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
>>>>>>>>>>>>>> terminate normally
>>>>>>>>>>>>>> even if the value of N is ∞.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But N steps in not ALL steps as required by the actual
>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Actually N steps is the exact definition of a UTM for those
>>>>>>>>>>>> N steps.
>>>>>>>>>>>> Just like with the H/D example after N steps we can see that
>>>>>>>>>>>> neither
>>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by
>>>>>>>>>>>> embedded_H
>>>>>>>>>>>> can possibly terminate normally.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, UTMs have no concept of only doing a partial simulation.
>>>>>>>>>>>
>>>>>>>>>> When a simulating halt decider correctly simulates N steps of
>>>>>>>>>> its input
>>>>>>>>>> it derives the exact same N steps that a pure UTM would derive
>>>>>>>>>> because
>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Just like a racing car is a street legal care with extra
>>>>>>>>> features that makes it no longer street legal.
>>>>>>>>>
>>>>>>>>> The fact that H aborts its simulation part way means it is no
>>>>>>>>> longer a UTM
>>>>>>>>
>>>>>>>> *Yet only at the point where it aborts its simulation*
>>>>>>>
>>>>>>> Right, but that affect the behavior of ALL copies of it, since
>>>>>>> they all act the same.
>>>>>>>
>>>>>>> Do you think you are immortal because you haven't died yet, and
>>>>>>> that everyone is immortal until the point in time they die?
>>>>>>>
>>>>>>> Since it just proves it isn't a UTM, it can't assume that the
>>>>>>> copy it is simulating is, it needs to account for that behavior.
>>>>>>>
>>>>>>> The fact that the DESIGN logic to do this goes into an infinite
>>>>>>> loop, doesn't mean that the program itself does.
>>>>>>>
>>>>>>> Since H aborts its simulation and returns 0, its input will see
>>>>>>> its copy do exactly the same thing and thus will Halt, making the
>>>>>>> answer wrong.
>>>>>>>
>>>>>>> Since H isn't a UTM, since if fails to meet the defintion, the
>>>>>>> fact that it can't reach a final state is irrelevent, as is any
>>>>>>> definiton of "Correct Simulation" that differs from what a UTM does.
>>>>>>>
>>>>>>> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which
>>>>>>> is what is allowed to replace the actual behavior of the machine)
>>>>>>> Halts, and thus the CORRECT answer is Halting.
>>>>>>>
>>>>>>> You are just showing that you have fallen for your own Strawman
>>>>>>> Deception that got you to use the wrong criteria.
>>>>>>>
>>>>>>>> At this point where it aborts its simulation we can see that it
>>>>>>>> must
>>>>>>>> do this to prevent its own infinite execution, thus conclusively
>>>>>>>> proving
>>>>>>>> that it correctly determined that its simulated input cannot
>>>>>>>> possibly
>>>>>>>> terminate normally.
>>>>>>>>
>>>>>>>> How much longer are you going to play the fool and deny this?
>>>>>>>>
>>>>>>>
>>>>>>> No, it does so because it has been programmed to do so, and thus
>>>>>>> ALL copies of it will do so.
>>>>>>>
>>>>>>> It makes the error assuming that the copy it is simulating will
>>>>>>> do something different than it does.
>>>>>>
>>>>>> It makes no error. As you already admitted D correctly simulated by H
>>>>>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩
>>>>>> correctly
>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>
>>>>>> Are you going to keep playing the fool on this?
>>>>>>
>>>>>
>>>>> Except that you are answering the wrong question.
>>>>>
>>>>
>>>> In other words you want to keep playing the fool and dodging the
>>>> actual question that I am actually asking.
>>>
>>> No, you are showing yourself to be the fool by not understand your
>>> own stupidity.
>>>
>>>>
>>>> So you agreed that D correctly simulated H cannot possibly terminate
>>>> normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by
>>>> embedded_H.
>>>
>>> No, I am saying that H can not correctly simulate the input H and
>>> give an answer. If H DOES try to correctly simulate its input, then
>>> it can never giv an answer.
>>
>> Since you already acknowledged that D correctly simulated by H can never
>> terminate normally and you did not need an infinite amount of time to
>> determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by embedded_H
>> can also be determined to never terminate normally and this
>> determination can be made in a finite amount of time.
>>
>> In both cases this can be correctly determined after N steps of
>> simulation thus no need for the infinite simulation that you keep
>> insisting is necessary.
>>
>>
>
> You keep on LYING about what I said. Any H that gives an answer can not
> "Correctly Simulate" this input per the definitions that allow
> simulation to replace the behavior of the actual machine.
>

On 5/21/23 2:12 PM, olcott wrote:
> On 5/21/2023 11:54 AM, Richard Damon wrote:
>> On 5/21/23 10:16 AM, olcott wrote:
>>> On 5/20/2023 6:52 PM, Richard Damon wrote:
>>>> On 5/20/23 5:29 PM, olcott wrote:
>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote:
>>>>>> On 5/20/23 5:10 PM, olcott wrote:
>>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote:
>>>>>>>> On 5/20/23 4:33 PM, olcott wrote:
>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote:
>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same
>>>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to
>>>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, which
>>>>>>>>>>>>>>>>>>>>>>>>>> you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So the software engineering really is over your
>>>>>>>>>>>>>>>>>>>>>>>>> head?
>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually
>>>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking about Software
>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about this
>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting Problem described by
>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the Halting Problem of
>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you
>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of what you are talking about,
>>>>>>>>>>>>>>>>>>>>>>>> so you don't understand the diference.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this way.
>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never
>>>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than
>>>>>>>>>>>>>>>>>>>>>>>> you have.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer an
>>>>>>>>>>>>>>>>>>>>>>> straight forward
>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to prove
>>>>>>>>>>>>>>>>>>>>>>> otherwise.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If the simulation by a UTM would be wrong then you
>>>>>>>>>>>>>>>>>>> would have to be able
>>>>>>>>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final
>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I don't know why you say this when you already know
>>>>>>>>>>>>>>>>> that ⟨Ĥ⟩ correctly
>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly terminate
>>>>>>>>>>>>>>>>> normally.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because embedded_H doesn't actually "Correctly Simulate"
>>>>>>>>>>>>>>>> its input by the definintion aquired by your mentioning
>>>>>>>>>>>>>>>> of a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You have already agreed that it does simulate the first N
>>>>>>>>>>>>>>> steps
>>>>>>>>>>>>>>> correctly. It is just as obvious that the behavior
>>>>>>>>>>>>>>> pattern of N steps of
>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
>>>>>>>>>>>>>>> terminate normally
>>>>>>>>>>>>>>> even if the value of N is ∞.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But N steps in not ALL steps as required by the actual
>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Actually N steps is the exact definition of a UTM for those
>>>>>>>>>>>>> N steps.
>>>>>>>>>>>>> Just like with the H/D example after N steps we can see
>>>>>>>>>>>>> that neither
>>>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by
>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>> can possibly terminate normally.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, UTMs have no concept of only doing a partial simulation.
>>>>>>>>>>>>
>>>>>>>>>>> When a simulating halt decider correctly simulates N steps of
>>>>>>>>>>> its input
>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>> derive because
>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Just like a racing car is a street legal care with extra
>>>>>>>>>> features that makes it no longer street legal.
>>>>>>>>>>
>>>>>>>>>> The fact that H aborts its simulation part way means it is no
>>>>>>>>>> longer a UTM
>>>>>>>>>
>>>>>>>>> *Yet only at the point where it aborts its simulation*
>>>>>>>>
>>>>>>>> Right, but that affect the behavior of ALL copies of it, since
>>>>>>>> they all act the same.
>>>>>>>>
>>>>>>>> Do you think you are immortal because you haven't died yet, and
>>>>>>>> that everyone is immortal until the point in time they die?
>>>>>>>>
>>>>>>>> Since it just proves it isn't a UTM, it can't assume that the
>>>>>>>> copy it is simulating is, it needs to account for that behavior.
>>>>>>>>
>>>>>>>> The fact that the DESIGN logic to do this goes into an infinite
>>>>>>>> loop, doesn't mean that the program itself does.
>>>>>>>>
>>>>>>>> Since H aborts its simulation and returns 0, its input will see
>>>>>>>> its copy do exactly the same thing and thus will Halt, making
>>>>>>>> the answer wrong.
>>>>>>>>
>>>>>>>> Since H isn't a UTM, since if fails to meet the defintion, the
>>>>>>>> fact that it can't reach a final state is irrelevent, as is any
>>>>>>>> definiton of "Correct Simulation" that differs from what a UTM
>>>>>>>> does.
>>>>>>>>
>>>>>>>> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which
>>>>>>>> is what is allowed to replace the actual behavior of the
>>>>>>>> machine) Halts, and thus the CORRECT answer is Halting.
>>>>>>>>
>>>>>>>> You are just showing that you have fallen for your own Strawman
>>>>>>>> Deception that got you to use the wrong criteria.
>>>>>>>>
>>>>>>>>> At this point where it aborts its simulation we can see that it
>>>>>>>>> must
>>>>>>>>> do this to prevent its own infinite execution, thus
>>>>>>>>> conclusively proving
>>>>>>>>> that it correctly determined that its simulated input cannot
>>>>>>>>> possibly
>>>>>>>>> terminate normally.
>>>>>>>>>
>>>>>>>>> How much longer are you going to play the fool and deny this?
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, it does so because it has been programmed to do so, and thus
>>>>>>>> ALL copies of it will do so.
>>>>>>>>
>>>>>>>> It makes the error assuming that the copy it is simulating will
>>>>>>>> do something different than it does.
>>>>>>>
>>>>>>> It makes no error. As you already admitted D correctly simulated
>>>>>>> by H
>>>>>>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩
>>>>>>> correctly
>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>
>>>>>>> Are you going to keep playing the fool on this?
>>>>>>>
>>>>>>
>>>>>> Except that you are answering the wrong question.
>>>>>>
>>>>>
>>>>> In other words you want to keep playing the fool and dodging the
>>>>> actual question that I am actually asking.
>>>>
>>>> No, you are showing yourself to be the fool by not understand your
>>>> own stupidity.
>>>>
>>>>>
>>>>> So you agreed that D correctly simulated H cannot possibly terminate
>>>>> normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by
>>>>> embedded_H.
>>>>
>>>> No, I am saying that H can not correctly simulate the input H and
>>>> give an answer. If H DOES try to correctly simulate its input, then
>>>> it can never giv an answer.
>>>
>>> Since you already acknowledged that D correctly simulated by H can never
>>> terminate normally and you did not need an infinite amount of time to
>>> determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by embedded_H
>>> can also be determined to never terminate normally and this
>>> determination can be made in a finite amount of time.
>>>
>>> In both cases this can be correctly determined after N steps of
>>> simulation thus no need for the infinite simulation that you keep
>>> insisting is necessary.
>>>
>>>
>>
>> You keep on LYING about what I said. Any H that gives an answer can
>> not "Correctly Simulate" this input per the definitions that allow
>> simulation to replace the behavior of the actual machine.
>>
>
> Since you already acknowledged that D correctly simulated by H cannot
> possibly terminate normally (hence [key agreement]) and the H/D pair is
> isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.
>
So?

On 5/21/2023 1:39 PM, Richard Damon wrote:
> On 5/21/23 2:12 PM, olcott wrote:
>> On 5/21/2023 11:54 AM, Richard Damon wrote:
>>> On 5/21/23 10:16 AM, olcott wrote:
>>>> On 5/20/2023 6:52 PM, Richard Damon wrote:
>>>>> On 5/20/23 5:29 PM, olcott wrote:
>>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote:
>>>>>>> On 5/20/23 5:10 PM, olcott wrote:
>>>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote:
>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote:
>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote:
>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same
>>>>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to
>>>>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem,
>>>>>>>>>>>>>>>>>>>>>>>>>>> which you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So the software engineering really is over
>>>>>>>>>>>>>>>>>>>>>>>>>> your head?
>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually
>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking about Software
>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about this
>>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting Problem described by
>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the Halting Problem of
>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you
>>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of what you are talking
>>>>>>>>>>>>>>>>>>>>>>>>> about, so you don't understand the diference.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this
>>>>>>>>>>>>>>>>>>>>>>>>>> way.
>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never
>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than
>>>>>>>>>>>>>>>>>>>>>>>>> you have.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer an
>>>>>>>>>>>>>>>>>>>>>>>> straight forward
>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to prove
>>>>>>>>>>>>>>>>>>>>>>>> otherwise.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If the simulation by a UTM would be wrong then you
>>>>>>>>>>>>>>>>>>>> would have to be able
>>>>>>>>>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final
>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I don't know why you say this when you already know
>>>>>>>>>>>>>>>>>> that ⟨Ĥ⟩ correctly
>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly terminate
>>>>>>>>>>>>>>>>>> normally.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because embedded_H doesn't actually "Correctly
>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired by your
>>>>>>>>>>>>>>>>> mentioning of a UTM.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You have already agreed that it does simulate the first
>>>>>>>>>>>>>>>> N steps
>>>>>>>>>>>>>>>> correctly. It is just as obvious that the behavior
>>>>>>>>>>>>>>>> pattern of N steps of
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
>>>>>>>>>>>>>>>> terminate normally
>>>>>>>>>>>>>>>> even if the value of N is ∞.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But N steps in not ALL steps as required by the actual
>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Actually N steps is the exact definition of a UTM for
>>>>>>>>>>>>>> those N steps.
>>>>>>>>>>>>>> Just like with the H/D example after N steps we can see
>>>>>>>>>>>>>> that neither
>>>>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by
>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>> can possibly terminate normally.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, UTMs have no concept of only doing a partial simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>> When a simulating halt decider correctly simulates N steps
>>>>>>>>>>>> of its input
>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>> derive because
>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Just like a racing car is a street legal care with extra
>>>>>>>>>>> features that makes it no longer street legal.
>>>>>>>>>>>
>>>>>>>>>>> The fact that H aborts its simulation part way means it is no
>>>>>>>>>>> longer a UTM
>>>>>>>>>>
>>>>>>>>>> *Yet only at the point where it aborts its simulation*
>>>>>>>>>
>>>>>>>>> Right, but that affect the behavior of ALL copies of it, since
>>>>>>>>> they all act the same.
>>>>>>>>>
>>>>>>>>> Do you think you are immortal because you haven't died yet, and
>>>>>>>>> that everyone is immortal until the point in time they die?
>>>>>>>>>
>>>>>>>>> Since it just proves it isn't a UTM, it can't assume that the
>>>>>>>>> copy it is simulating is, it needs to account for that behavior.
>>>>>>>>>
>>>>>>>>> The fact that the DESIGN logic to do this goes into an infinite
>>>>>>>>> loop, doesn't mean that the program itself does.
>>>>>>>>>
>>>>>>>>> Since H aborts its simulation and returns 0, its input will see
>>>>>>>>> its copy do exactly the same thing and thus will Halt, making
>>>>>>>>> the answer wrong.
>>>>>>>>>
>>>>>>>>> Since H isn't a UTM, since if fails to meet the defintion, the
>>>>>>>>> fact that it can't reach a final state is irrelevent, as is any
>>>>>>>>> definiton of "Correct Simulation" that differs from what a UTM
>>>>>>>>> does.
>>>>>>>>>
>>>>>>>>> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM
>>>>>>>>> which is what is allowed to replace the actual behavior of the
>>>>>>>>> machine) Halts, and thus the CORRECT answer is Halting.
>>>>>>>>>
>>>>>>>>> You are just showing that you have fallen for your own Strawman
>>>>>>>>> Deception that got you to use the wrong criteria.
>>>>>>>>>
>>>>>>>>>> At this point where it aborts its simulation we can see that
>>>>>>>>>> it must
>>>>>>>>>> do this to prevent its own infinite execution, thus
>>>>>>>>>> conclusively proving
>>>>>>>>>> that it correctly determined that its simulated input cannot
>>>>>>>>>> possibly
>>>>>>>>>> terminate normally.
>>>>>>>>>>
>>>>>>>>>> How much longer are you going to play the fool and deny this?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, it does so because it has been programmed to do so, and
>>>>>>>>> thus ALL copies of it will do so.
>>>>>>>>>
>>>>>>>>> It makes the error assuming that the copy it is simulating will
>>>>>>>>> do something different than it does.
>>>>>>>>
>>>>>>>> It makes no error. As you already admitted D correctly simulated
>>>>>>>> by H
>>>>>>>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩
>>>>>>>> correctly
>>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>>
>>>>>>>> Are you going to keep playing the fool on this?
>>>>>>>>
>>>>>>>
>>>>>>> Except that you are answering the wrong question.
>>>>>>>
>>>>>>
>>>>>> In other words you want to keep playing the fool and dodging the
>>>>>> actual question that I am actually asking.
>>>>>
>>>>> No, you are showing yourself to be the fool by not understand your
>>>>> own stupidity.
>>>>>
>>>>>>
>>>>>> So you agreed that D correctly simulated H cannot possibly terminate
>>>>>> normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by
>>>>>> embedded_H.
>>>>>
>>>>> No, I am saying that H can not correctly simulate the input H and
>>>>> give an answer. If H DOES try to correctly simulate its input, then
>>>>> it can never giv an answer.
>>>>
>>>> Since you already acknowledged that D correctly simulated by H can
>>>> never
>>>> terminate normally and you did not need an infinite amount of time to
>>>> determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by
>>>> embedded_H
>>>> can also be determined to never terminate normally and this
>>>> determination can be made in a finite amount of time.
>>>>
>>>> In both cases this can be correctly determined after N steps of
>>>> simulation thus no need for the infinite simulation that you keep
>>>> insisting is necessary.
>>>>
>>>>
>>>
>>> You keep on LYING about what I said. Any H that gives an answer can
>>> not "Correctly Simulate" this input per the definitions that allow
>>> simulation to replace the behavior of the actual machine.
>>>
>>
>> Since you already acknowledged that D correctly simulated by H cannot
>> possibly terminate normally (hence [key agreement]) and the H/D pair is
>> isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.
>>
> So?
>
> D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that answer is
> wrong for the Halting Problem.

On 5/21/23 2:50 PM, olcott wrote:
> On 5/21/2023 1:39 PM, Richard Damon wrote:
>> On 5/21/23 2:12 PM, olcott wrote:
>>> On 5/21/2023 11:54 AM, Richard Damon wrote:
>>>> On 5/21/23 10:16 AM, olcott wrote:
>>>>> On 5/20/2023 6:52 PM, Richard Damon wrote:
>>>>>> On 5/20/23 5:29 PM, olcott wrote:
>>>>>>> On 5/20/2023 4:24 PM, Richard Damon wrote:
>>>>>>>> On 5/20/23 5:10 PM, olcott wrote:
>>>>>>>>> On 5/20/2023 3:48 PM, Richard Damon wrote:
>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote:
>>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote:
>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:
>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same dodge by Ben.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> which you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So the software engineering really is over
>>>>>>>>>>>>>>>>>>>>>>>>>>> your head?
>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually
>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But you aren't talking about Software
>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about this
>>>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting Problem described by
>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the Halting Problem of
>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Of course, the likely explanation is that you
>>>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of what you are talking
>>>>>>>>>>>>>>>>>>>>>>>>>> about, so you don't understand the diference.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this
>>>>>>>>>>>>>>>>>>>>>>>>>>> way.
>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never
>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have possibly written more WORKING code than
>>>>>>>>>>>>>>>>>>>>>>>>>> you have.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I don't believe you. Your inability to answer
>>>>>>>>>>>>>>>>>>>>>>>>> an straight forward
>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to prove
>>>>>>>>>>>>>>>>>>>>>>>>> otherwise.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> but that is because H doesn't, and can never do an
>>>>>>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If the simulation by a UTM would be wrong then you
>>>>>>>>>>>>>>>>>>>>> would have to be able
>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, the simulation by a ACTUAL UTM will reach a
>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I don't know why you say this when you already know
>>>>>>>>>>>>>>>>>>> that ⟨Ĥ⟩ correctly
>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly terminate
>>>>>>>>>>>>>>>>>>> normally.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Because embedded_H doesn't actually "Correctly
>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired by your
>>>>>>>>>>>>>>>>>> mentioning of a UTM.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You have already agreed that it does simulate the first
>>>>>>>>>>>>>>>>> N steps
>>>>>>>>>>>>>>>>> correctly. It is just as obvious that the behavior
>>>>>>>>>>>>>>>>> pattern of N steps of
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly
>>>>>>>>>>>>>>>>> terminate normally
>>>>>>>>>>>>>>>>> even if the value of N is ∞.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But N steps in not ALL steps as required by the actual
>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Actually N steps is the exact definition of a UTM for
>>>>>>>>>>>>>>> those N steps.
>>>>>>>>>>>>>>> Just like with the H/D example after N steps we can see
>>>>>>>>>>>>>>> that neither
>>>>>>>>>>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by
>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>> can possibly terminate normally.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, UTMs have no concept of only doing a partial
>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> When a simulating halt decider correctly simulates N steps
>>>>>>>>>>>>> of its input
>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>> derive because
>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Just like a racing car is a street legal care with extra
>>>>>>>>>>>> features that makes it no longer street legal.
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that H aborts its simulation part way means it is
>>>>>>>>>>>> no longer a UTM
>>>>>>>>>>>
>>>>>>>>>>> *Yet only at the point where it aborts its simulation*
>>>>>>>>>>
>>>>>>>>>> Right, but that affect the behavior of ALL copies of it, since
>>>>>>>>>> they all act the same.
>>>>>>>>>>
>>>>>>>>>> Do you think you are immortal because you haven't died yet,
>>>>>>>>>> and that everyone is immortal until the point in time they die?
>>>>>>>>>>
>>>>>>>>>> Since it just proves it isn't a UTM, it can't assume that the
>>>>>>>>>> copy it is simulating is, it needs to account for that behavior.
>>>>>>>>>>
>>>>>>>>>> The fact that the DESIGN logic to do this goes into an
>>>>>>>>>> infinite loop, doesn't mean that the program itself does.
>>>>>>>>>>
>>>>>>>>>> Since H aborts its simulation and returns 0, its input will
>>>>>>>>>> see its copy do exactly the same thing and thus will Halt,
>>>>>>>>>> making the answer wrong.
>>>>>>>>>>
>>>>>>>>>> Since H isn't a UTM, since if fails to meet the defintion, the
>>>>>>>>>> fact that it can't reach a final state is irrelevent, as is
>>>>>>>>>> any definiton of "Correct Simulation" that differs from what a
>>>>>>>>>> UTM does.
>>>>>>>>>>
>>>>>>>>>> UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM
>>>>>>>>>> which is what is allowed to replace the actual behavior of the
>>>>>>>>>> machine) Halts, and thus the CORRECT answer is Halting.
>>>>>>>>>>
>>>>>>>>>> You are just showing that you have fallen for your own
>>>>>>>>>> Strawman Deception that got you to use the wrong criteria.
>>>>>>>>>>
>>>>>>>>>>> At this point where it aborts its simulation we can see that
>>>>>>>>>>> it must
>>>>>>>>>>> do this to prevent its own infinite execution, thus
>>>>>>>>>>> conclusively proving
>>>>>>>>>>> that it correctly determined that its simulated input cannot
>>>>>>>>>>> possibly
>>>>>>>>>>> terminate normally.
>>>>>>>>>>>
>>>>>>>>>>> How much longer are you going to play the fool and deny this?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, it does so because it has been programmed to do so, and
>>>>>>>>>> thus ALL copies of it will do so.
>>>>>>>>>>
>>>>>>>>>> It makes the error assuming that the copy it is simulating
>>>>>>>>>> will do something different than it does.
>>>>>>>>>
>>>>>>>>> It makes no error. As you already admitted D correctly
>>>>>>>>> simulated by H
>>>>>>>>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩
>>>>>>>>> correctly
>>>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>>>>
>>>>>>>>> Are you going to keep playing the fool on this?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Except that you are answering the wrong question.
>>>>>>>>
>>>>>>>
>>>>>>> In other words you want to keep playing the fool and dodging the
>>>>>>> actual question that I am actually asking.
>>>>>>
>>>>>> No, you are showing yourself to be the fool by not understand your
>>>>>> own stupidity.
>>>>>>
>>>>>>>
>>>>>>> So you agreed that D correctly simulated H cannot possibly terminate
>>>>>>> normally and the exact same thing goes for ⟨Ĥ⟩ correctly
>>>>>>> simulated by
>>>>>>> embedded_H.
>>>>>>
>>>>>> No, I am saying that H can not correctly simulate the input H and
>>>>>> give an answer. If H DOES try to correctly simulate its input,
>>>>>> then it can never giv an answer.
>>>>>
>>>>> Since you already acknowledged that D correctly simulated by H can
>>>>> never
>>>>> terminate normally and you did not need an infinite amount of time to
>>>>> determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by
>>>>> embedded_H
>>>>> can also be determined to never terminate normally and this
>>>>> determination can be made in a finite amount of time.
>>>>>
>>>>> In both cases this can be correctly determined after N steps of
>>>>> simulation thus no need for the infinite simulation that you keep
>>>>> insisting is necessary.
>>>>>
>>>>>
>>>>
>>>> You keep on LYING about what I said. Any H that gives an answer can
>>>> not "Correctly Simulate" this input per the definitions that allow
>>>> simulation to replace the behavior of the actual machine.
>>>>
>>>
>>> Since you already acknowledged that D correctly simulated by H cannot
>>> possibly terminate normally (hence [key agreement]) and the H/D pair is
>>> isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.
>>>
>> So?
>>
>> D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that answer
>> is wrong for the Halting Problem.
>
> It only seems wrong because all of the textbooks reject simulating
> halt deciders out-of-hand without review incorrectly assuming that
> simulation cannot possibly be used as the basis of a halt decider: