On 5/23/2023 7:38 PM, Richard Damon wrote:
> On 5/23/23 9:50 AM, olcott wrote:
>> On 5/23/2023 6:44 AM, Richard Damon wrote:
>>> On 5/22/23 11:31 PM, olcott wrote:
>>>> On 5/22/2023 10:12 PM, Richard Damon wrote:
>>>>> On 5/22/23 10:49 PM, olcott wrote:
>>>>>> On 5/22/2023 9:27 PM, olcott wrote:
>>>>>>> On 5/22/2023 9:02 PM, Richard Damon wrote:
>>>>>>>> On 5/22/23 9:33 PM, olcott wrote:
>>>>>>>>> On 5/22/2023 6:22 PM, Richard Damon wrote:
>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote:
>>>>>>>>>>> On 5/21/2023 2:02 PM, Richard Damon wrote:
>>>>>>>>>>>> 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:
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, it is wrong because the question asks about the actual
>>>>>>>>>>>> machine, and that halts, so the right answer is HALTING.
>>>>>>>>>>>>
>>>>>>>>>>> Yet any theory of computation computer scientist knows that a
>>>>>>>>>>> simulation
>>>>>>>>>>> of N steps by a UTM does provide that actual behavior of the
>>>>>>>>>>> actual
>>>>>>>>>>> input to this UTM.
>>>>>>>>>>
>>>>>>>>>> Nope, only if the machine reaches a final state in that Nth Step.
>>>>>>>>>>
>>>>>>>>>> You just don't understand what a UTM is or what it does.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> They also know that when the input to this UTM is defined to
>>>>>>>>>>> have a
>>>>>>>>>>> pathological relationship to this UTM that this changes the
>>>>>>>>>>> behavior of
>>>>>>>>>>> this correctly simulated input.
>>>>>>>>>>
>>>>>>>>>> Nope, a UTM simulation is only correct if it exactly matches
>>>>>>>>>> the FULL b4ehavior of the machine it is looking at. That is
>>>>>>>>>> its DEFINITION.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Maybe I should begin my paper with this self-evident truth
>>>>>>>>>>> before
>>>>>>>>>>> proceeding to the notion of a simulating halt decider.
>>>>>>>>>>
>>>>>>>>>> Yes, do that, so anyone who actually understand the theory
>>>>>>>>>> knows from that start that you are a crackpot.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> In any case the perfect isomorphism between H/D and
>>>>>>>>>>> embedded_H / ⟨Ĥ⟩
>>>>>>>>>>> already fully proves this point.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Why, since neither H or embedded_H are actually UTMs, and it
>>>>>>>>>> is establishied that both of them declare their input to be
>>>>>>>>>> non-halting when the machine they are given the description of
>>>>>>>>>> Halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *Clearly you are clueless about what the term isomorphism means*
>>>>>>>>> Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩
>>>>>>>>> attempt to
>>>>>>>>> do the opposite of whatever their corresponding halt decider
>>>>>>>>> determines.
>>>>>>>>>
>>>>>>>>> Both of them loop when their halt decider returns {halts} and
>>>>>>>>> both halt
>>>>>>>>> when their halt decider returns {non-halting}. Both of them
>>>>>>>>> continue to
>>>>>>>>> call the halt decider in recursive simulation until their halt
>>>>>>>>> decider
>>>>>>>>> stops simulating them.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, so since the Halt Decider must have a defined behavior
>>>>>>>> when given them as an input, that defined behavior will always
>>>>>>>> be wrong, because no matter how you define your H, the machines
>>>>>>>> will act the other way. This is what proves that there can't be
>>>>>>>> a decider that gets all input right.
>>>>>>>>
>>>>>>>
>>>>>>> I did not say that precisely enough.
>>>>>>>
>>>>>>> Both of the simulated inputs [WOULD] loop if their corresponding
>>>>>>> halt
>>>>>>> decider [WOULD] return {halts} to them and [WOULD] halt loop if
>>>>>>> their
>>>>>>> corresponding halt decider [WOULD] return {non-halting} to them
>>>>>>> yet the
>>>>>>> actual case is that they remain stuck in recursive simulation until
>>>>>>> their corresponding halt decider stops simulating them.
>>>>>>>
>>>>>>> Thus as you admitted for the H/D pair also applies to the
>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate
>>>>>>> normally because it remains stuck in recursive simulation until the
>>>>>>> simulation is terminated *IN BOTH CASES*
>>>>>>
>>>>>> You seem to be acting like the HBO Westworld character Bernard
>>>>>> that was
>>>>>> a robot (AKA host) was almost perfectly a very smart human except
>>>>>> that
>>>>>> his brain was hard-wired to not be able to "see" a specific door.
>>>>>>
>>>>>> Then, once they're inside the dark house where Ford's robotic family
>>>>>> lives, Theresa asks what's behind one of the doors. "What door?"
>>>>>> Bernard
>>>>>> asks, and that's when you know he's a host as well. The door is
>>>>>> plain as
>>>>>> day, even in the dark, and he's been there before. And yet, he
>>>>>> couldn't
>>>>>> see it.
>>>>>>
>>>>>> https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
>>>>>>
>>>>>
>>>>> So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in
>>>>> their execution path?
>>>>>
>>>>> You claim they differ, so show it.
>>>>>
>>>>
>>>> If you really do know software engineering then you already know on the
>>>> basis that you already agreed that D simulated by H cannot terminate
>>>> normally.
>>>>
>>>
>>> Yes, but the question isn't what does the (partial) simulation by H
>>> show, but what does the machine repesented by the input do.
>>>
>>> Since H doesn't simulate all of the behavior of D, its simulation
>>> doesn't directly prove that answer.
>>>
>>>> When you ask a question that you already know the answer to then you
>>>> are
>>>> only playing head games.
>>>
>>> Excdpt what the simulation by H does isn't the question that H is
>>> supposed to be answering.
>>>
>>>>
>>>>> That, or you are claiming that a "Correct Simulation" can differ
>>>>> from the actual machine behavior, despite that going against the
>>>>> definition.
>>>>>
>>>>
>>>> You already admitted that D simulated by H never terminates normally.
>>>> Thus you knew that H is correct to abort its simulation of D to prevent
>>>> its own infinite execution.
>>>
>>> H is allowed to abort its simulation for any reason its programmer
>>> wants. It still needs to give the right answer to be correct, and
>>> that answer needs to describe the behavior of directly running the
>>> machine given an input.
>>>
>>> Since H(D,D) has been said to return 0, we can by simple inspection,
>>> and verify by actually running it, see that D(D) will Halt, which
>>> means that H's answer is just wrong.
>>>
>>> It might be a correct POOP decider, but only you seem interested in
>>> your POOP.
>>>
>>>>
>>>> The reason that I did this concretely in C is the there is no wiggle
>>>> room of ambiguity to deny what is actually occurring.
>>
>> My way results in a halt decider that recognizes the actual behavior of
>> the actual input so that it doesn't get stuck in recursive simulation.
>
> No, becase the ACTUAL BEHAVIOR of the machine in question is what it
> does when actually run.
You keep insisting on staying out-of-sync by one recursive invocation.

On 5/23/23 9:19 PM, olcott wrote:
> On 5/23/2023 7:38 PM, Richard Damon wrote:
>> On 5/23/23 9:50 AM, olcott wrote:
>>> On 5/23/2023 6:44 AM, Richard Damon wrote:
>>>> On 5/22/23 11:31 PM, olcott wrote:
>>>>> On 5/22/2023 10:12 PM, Richard Damon wrote:
>>>>>> On 5/22/23 10:49 PM, olcott wrote:
>>>>>>> On 5/22/2023 9:27 PM, olcott wrote:
>>>>>>>> On 5/22/2023 9:02 PM, Richard Damon wrote:
>>>>>>>>> On 5/22/23 9:33 PM, olcott wrote:
>>>>>>>>>> On 5/22/2023 6:22 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote:
>>>>>>>>>>>> On 5/21/2023 2:02 PM, Richard Damon wrote:
>>>>>>>>>>>>> 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:
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it is wrong because the question asks about the actual
>>>>>>>>>>>>> machine, and that halts, so the right answer is HALTING.
>>>>>>>>>>>>>
>>>>>>>>>>>> Yet any theory of computation computer scientist knows that
>>>>>>>>>>>> a simulation
>>>>>>>>>>>> of N steps by a UTM does provide that actual behavior of the
>>>>>>>>>>>> actual
>>>>>>>>>>>> input to this UTM.
>>>>>>>>>>>
>>>>>>>>>>> Nope, only if the machine reaches a final state in that Nth
>>>>>>>>>>> Step.
>>>>>>>>>>>
>>>>>>>>>>> You just don't understand what a UTM is or what it does.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> They also know that when the input to this UTM is defined to
>>>>>>>>>>>> have a
>>>>>>>>>>>> pathological relationship to this UTM that this changes the
>>>>>>>>>>>> behavior of
>>>>>>>>>>>> this correctly simulated input.
>>>>>>>>>>>
>>>>>>>>>>> Nope, a UTM simulation is only correct if it exactly matches
>>>>>>>>>>> the FULL b4ehavior of the machine it is looking at. That is
>>>>>>>>>>> its DEFINITION.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Maybe I should begin my paper with this self-evident truth
>>>>>>>>>>>> before
>>>>>>>>>>>> proceeding to the notion of a simulating halt decider.
>>>>>>>>>>>
>>>>>>>>>>> Yes, do that, so anyone who actually understand the theory
>>>>>>>>>>> knows from that start that you are a crackpot.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> In any case the perfect isomorphism between H/D and
>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩
>>>>>>>>>>>> already fully proves this point.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Why, since neither H or embedded_H are actually UTMs, and it
>>>>>>>>>>> is establishied that both of them declare their input to be
>>>>>>>>>>> non-halting when the machine they are given the description
>>>>>>>>>>> of Halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *Clearly you are clueless about what the term isomorphism means*
>>>>>>>>>> Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩
>>>>>>>>>> attempt to
>>>>>>>>>> do the opposite of whatever their corresponding halt decider
>>>>>>>>>> determines.
>>>>>>>>>>
>>>>>>>>>> Both of them loop when their halt decider returns {halts} and
>>>>>>>>>> both halt
>>>>>>>>>> when their halt decider returns {non-halting}. Both of them
>>>>>>>>>> continue to
>>>>>>>>>> call the halt decider in recursive simulation until their halt
>>>>>>>>>> decider
>>>>>>>>>> stops simulating them.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, so since the Halt Decider must have a defined behavior
>>>>>>>>> when given them as an input, that defined behavior will always
>>>>>>>>> be wrong, because no matter how you define your H, the machines
>>>>>>>>> will act the other way. This is what proves that there can't be
>>>>>>>>> a decider that gets all input right.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I did not say that precisely enough.
>>>>>>>>
>>>>>>>> Both of the simulated inputs [WOULD] loop if their corresponding
>>>>>>>> halt
>>>>>>>> decider [WOULD] return {halts} to them and [WOULD] halt loop if
>>>>>>>> their
>>>>>>>> corresponding halt decider [WOULD] return {non-halting} to them
>>>>>>>> yet the
>>>>>>>> actual case is that they remain stuck in recursive simulation until
>>>>>>>> their corresponding halt decider stops simulating them.
>>>>>>>>
>>>>>>>> Thus as you admitted for the H/D pair also applies to the
>>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly
>>>>>>>> terminate
>>>>>>>> normally because it remains stuck in recursive simulation until the
>>>>>>>> simulation is terminated *IN BOTH CASES*
>>>>>>>
>>>>>>> You seem to be acting like the HBO Westworld character Bernard
>>>>>>> that was
>>>>>>> a robot (AKA host) was almost perfectly a very smart human except
>>>>>>> that
>>>>>>> his brain was hard-wired to not be able to "see" a specific door.
>>>>>>>
>>>>>>> Then, once they're inside the dark house where Ford's robotic family
>>>>>>> lives, Theresa asks what's behind one of the doors. "What door?"
>>>>>>> Bernard
>>>>>>> asks, and that's when you know he's a host as well. The door is
>>>>>>> plain as
>>>>>>> day, even in the dark, and he's been there before. And yet, he
>>>>>>> couldn't
>>>>>>> see it.
>>>>>>>
>>>>>>> https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
>>>>>>>
>>>>>>
>>>>>> So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in
>>>>>> their execution path?
>>>>>>
>>>>>> You claim they differ, so show it.
>>>>>>
>>>>>
>>>>> If you really do know software engineering then you already know on
>>>>> the
>>>>> basis that you already agreed that D simulated by H cannot terminate
>>>>> normally.
>>>>>
>>>>
>>>> Yes, but the question isn't what does the (partial) simulation by H
>>>> show, but what does the machine repesented by the input do.
>>>>
>>>> Since H doesn't simulate all of the behavior of D, its simulation
>>>> doesn't directly prove that answer.
>>>>
>>>>> When you ask a question that you already know the answer to then
>>>>> you are
>>>>> only playing head games.
>>>>
>>>> Excdpt what the simulation by H does isn't the question that H is
>>>> supposed to be answering.
>>>>
>>>>>
>>>>>> That, or you are claiming that a "Correct Simulation" can differ
>>>>>> from the actual machine behavior, despite that going against the
>>>>>> definition.
>>>>>>
>>>>>
>>>>> You already admitted that D simulated by H never terminates normally.
>>>>> Thus you knew that H is correct to abort its simulation of D to
>>>>> prevent
>>>>> its own infinite execution.
>>>>
>>>> H is allowed to abort its simulation for any reason its programmer
>>>> wants. It still needs to give the right answer to be correct, and
>>>> that answer needs to describe the behavior of directly running the
>>>> machine given an input.
>>>>
>>>> Since H(D,D) has been said to return 0, we can by simple inspection,
>>>> and verify by actually running it, see that D(D) will Halt, which
>>>> means that H's answer is just wrong.
>>>>
>>>> It might be a correct POOP decider, but only you seem interested in
>>>> your POOP.
>>>>
>>>>>
>>>>> The reason that I did this concretely in C is the there is no wiggle
>>>>> room of ambiguity to deny what is actually occurring.
>>>
>>> My way results in a halt decider that recognizes the actual behavior of
>>> the actual input so that it doesn't get stuck in recursive simulation.
>>
>> No, becase the ACTUAL BEHAVIOR of the machine in question is what it
>> does when actually run.
>>
>> Since H doesn't do a simulation that meets the ACTUAL requirements of
>> a UTM, it results don't count.
>>
>> Since D(D) Halts, H(D,D) returning zero CAN'T be correct.
>>
>> All you have done is solved a Strawman Problem, which isn't a solution
>> to the problem in question.
>>
>>>
>>> You way simply denies the reality actual behavior of the actual input
>>> and gets stuck in infinite recursion.
>>
>> The ACTUAL BEHAVIOR is DEFINED as what the ACTUAL MACHINE does.
>>
> You keep insisting on staying out-of-sync by one recursive invocation.
>

On 5/24/23 11:47 AM, olcott wrote:
> On 5/23/2023 7:38 PM, Richard Damon wrote:
>> On 5/23/23 9:50 AM, olcott wrote:
>>> On 5/23/2023 6:44 AM, Richard Damon wrote:
>>>> On 5/22/23 11:31 PM, olcott wrote:
>>>>> On 5/22/2023 10:12 PM, Richard Damon wrote:
>>>>>> On 5/22/23 10:49 PM, olcott wrote:
>>>>>>> On 5/22/2023 9:27 PM, olcott wrote:
>>>>>>>> On 5/22/2023 9:02 PM, Richard Damon wrote:
>>>>>>>>> On 5/22/23 9:33 PM, olcott wrote:
>>>>>>>>>> On 5/22/2023 6:22 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote:
>>>>>>>>>>>> On 5/21/2023 2:02 PM, Richard Damon wrote:
>>>>>>>>>>>>> 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:
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it is wrong because the question asks about the actual
>>>>>>>>>>>>> machine, and that halts, so the right answer is HALTING.
>>>>>>>>>>>>>
>>>>>>>>>>>> Yet any theory of computation computer scientist knows that
>>>>>>>>>>>> a simulation
>>>>>>>>>>>> of N steps by a UTM does provide that actual behavior of the
>>>>>>>>>>>> actual
>>>>>>>>>>>> input to this UTM.
>>>>>>>>>>>
>>>>>>>>>>> Nope, only if the machine reaches a final state in that Nth
>>>>>>>>>>> Step.
>>>>>>>>>>>
>>>>>>>>>>> You just don't understand what a UTM is or what it does.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> They also know that when the input to this UTM is defined to
>>>>>>>>>>>> have a
>>>>>>>>>>>> pathological relationship to this UTM that this changes the
>>>>>>>>>>>> behavior of
>>>>>>>>>>>> this correctly simulated input.
>>>>>>>>>>>
>>>>>>>>>>> Nope, a UTM simulation is only correct if it exactly matches
>>>>>>>>>>> the FULL b4ehavior of the machine it is looking at. That is
>>>>>>>>>>> its DEFINITION.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Maybe I should begin my paper with this self-evident truth
>>>>>>>>>>>> before
>>>>>>>>>>>> proceeding to the notion of a simulating halt decider.
>>>>>>>>>>>
>>>>>>>>>>> Yes, do that, so anyone who actually understand the theory
>>>>>>>>>>> knows from that start that you are a crackpot.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> In any case the perfect isomorphism between H/D and
>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩
>>>>>>>>>>>> already fully proves this point.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Why, since neither H or embedded_H are actually UTMs, and it
>>>>>>>>>>> is establishied that both of them declare their input to be
>>>>>>>>>>> non-halting when the machine they are given the description
>>>>>>>>>>> of Halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *Clearly you are clueless about what the term isomorphism means*
>>>>>>>>>> Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩
>>>>>>>>>> attempt to
>>>>>>>>>> do the opposite of whatever their corresponding halt decider
>>>>>>>>>> determines.
>>>>>>>>>>
>>>>>>>>>> Both of them loop when their halt decider returns {halts} and
>>>>>>>>>> both halt
>>>>>>>>>> when their halt decider returns {non-halting}. Both of them
>>>>>>>>>> continue to
>>>>>>>>>> call the halt decider in recursive simulation until their halt
>>>>>>>>>> decider
>>>>>>>>>> stops simulating them.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, so since the Halt Decider must have a defined behavior
>>>>>>>>> when given them as an input, that defined behavior will always
>>>>>>>>> be wrong, because no matter how you define your H, the machines
>>>>>>>>> will act the other way. This is what proves that there can't be
>>>>>>>>> a decider that gets all input right.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I did not say that precisely enough.
>>>>>>>>
>>>>>>>> Both of the simulated inputs [WOULD] loop if their corresponding
>>>>>>>> halt
>>>>>>>> decider [WOULD] return {halts} to them and [WOULD] halt loop if
>>>>>>>> their
>>>>>>>> corresponding halt decider [WOULD] return {non-halting} to them
>>>>>>>> yet the
>>>>>>>> actual case is that they remain stuck in recursive simulation until
>>>>>>>> their corresponding halt decider stops simulating them.
>>>>>>>>
>>>>>>>> Thus as you admitted for the H/D pair also applies to the
>>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly
>>>>>>>> terminate
>>>>>>>> normally because it remains stuck in recursive simulation until the
>>>>>>>> simulation is terminated *IN BOTH CASES*
>>>>>>>
>>>>>>> You seem to be acting like the HBO Westworld character Bernard
>>>>>>> that was
>>>>>>> a robot (AKA host) was almost perfectly a very smart human except
>>>>>>> that
>>>>>>> his brain was hard-wired to not be able to "see" a specific door.
>>>>>>>
>>>>>>> Then, once they're inside the dark house where Ford's robotic family
>>>>>>> lives, Theresa asks what's behind one of the doors. "What door?"
>>>>>>> Bernard
>>>>>>> asks, and that's when you know he's a host as well. The door is
>>>>>>> plain as
>>>>>>> day, even in the dark, and he's been there before. And yet, he
>>>>>>> couldn't
>>>>>>> see it.
>>>>>>>
>>>>>>> https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
>>>>>>>
>>>>>>
>>>>>> So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in
>>>>>> their execution path?
>>>>>>
>>>>>> You claim they differ, so show it.
>>>>>>
>>>>>
>>>>> If you really do know software engineering then you already know on
>>>>> the
>>>>> basis that you already agreed that D simulated by H cannot terminate
>>>>> normally.
>>>>>
>>>>
>>>> Yes, but the question isn't what does the (partial) simulation by H
>>>> show, but what does the machine repesented by the input do.
>>>>
>>>> Since H doesn't simulate all of the behavior of D, its simulation
>>>> doesn't directly prove that answer.
>>>>
>>>>> When you ask a question that you already know the answer to then
>>>>> you are
>>>>> only playing head games.
>>>>
>>>> Excdpt what the simulation by H does isn't the question that H is
>>>> supposed to be answering.
>>>>
>>>>>
>>>>>> That, or you are claiming that a "Correct Simulation" can differ
>>>>>> from the actual machine behavior, despite that going against the
>>>>>> definition.
>>>>>>
>>>>>
>>>>> You already admitted that D simulated by H never terminates normally.
>>>>> Thus you knew that H is correct to abort its simulation of D to
>>>>> prevent
>>>>> its own infinite execution.
>>>>
>>>> H is allowed to abort its simulation for any reason its programmer
>>>> wants. It still needs to give the right answer to be correct, and
>>>> that answer needs to describe the behavior of directly running the
>>>> machine given an input.
>>>>
>>>> Since H(D,D) has been said to return 0, we can by simple inspection,
>>>> and verify by actually running it, see that D(D) will Halt, which
>>>> means that H's answer is just wrong.
>>>>
>>>> It might be a correct POOP decider, but only you seem interested in
>>>> your POOP.
>>>>
>>>>>
>>>>> The reason that I did this concretely in C is the there is no wiggle
>>>>> room of ambiguity to deny what is actually occurring.
>>>
>>> My way results in a halt decider that recognizes the actual behavior of
>>> the actual input so that it doesn't get stuck in recursive simulation.
>>
>> No, becase the ACTUAL BEHAVIOR of the machine in question is what it
>> does when actually run.
> You keep insisting on staying out-of-sync by one recursive invocation.
>
> Can D correctly simulated by H terminate normally?

On 5/24/2023 10:57 AM, Richard Damon wrote:
> On 5/24/23 11:47 AM, olcott wrote:
>> On 5/23/2023 7:38 PM, Richard Damon wrote:
>>> On 5/23/23 9:50 AM, olcott wrote:
>>>> On 5/23/2023 6:44 AM, Richard Damon wrote:
>>>>> On 5/22/23 11:31 PM, olcott wrote:
>>>>>> On 5/22/2023 10:12 PM, Richard Damon wrote:
>>>>>>> On 5/22/23 10:49 PM, olcott wrote:
>>>>>>>> On 5/22/2023 9:27 PM, olcott wrote:
>>>>>>>>> On 5/22/2023 9:02 PM, Richard Damon wrote:
>>>>>>>>>> On 5/22/23 9:33 PM, olcott wrote:
>>>>>>>>>>> On 5/22/2023 6:22 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote:
>>>>>>>>>>>>> On 5/21/2023 2:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>> 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:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, it is wrong because the question asks about the actual
>>>>>>>>>>>>>> machine, and that halts, so the right answer is HALTING.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Yet any theory of computation computer scientist knows that
>>>>>>>>>>>>> a simulation
>>>>>>>>>>>>> of N steps by a UTM does provide that actual behavior of
>>>>>>>>>>>>> the actual
>>>>>>>>>>>>> input to this UTM.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, only if the machine reaches a final state in that Nth
>>>>>>>>>>>> Step.
>>>>>>>>>>>>
>>>>>>>>>>>> You just don't understand what a UTM is or what it does.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> They also know that when the input to this UTM is defined
>>>>>>>>>>>>> to have a
>>>>>>>>>>>>> pathological relationship to this UTM that this changes the
>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>> this correctly simulated input.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, a UTM simulation is only correct if it exactly matches
>>>>>>>>>>>> the FULL b4ehavior of the machine it is looking at. That is
>>>>>>>>>>>> its DEFINITION.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe I should begin my paper with this self-evident truth
>>>>>>>>>>>>> before
>>>>>>>>>>>>> proceeding to the notion of a simulating halt decider.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, do that, so anyone who actually understand the theory
>>>>>>>>>>>> knows from that start that you are a crackpot.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> In any case the perfect isomorphism between H/D and
>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩
>>>>>>>>>>>>> already fully proves this point.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Why, since neither H or embedded_H are actually UTMs, and it
>>>>>>>>>>>> is establishied that both of them declare their input to be
>>>>>>>>>>>> non-halting when the machine they are given the description
>>>>>>>>>>>> of Halt.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *Clearly you are clueless about what the term isomorphism means*
>>>>>>>>>>> Both D and ⟨Ĥ⟩ have the exact same form in that both D and
>>>>>>>>>>> ⟨Ĥ⟩ attempt to
>>>>>>>>>>> do the opposite of whatever their corresponding halt decider
>>>>>>>>>>> determines.
>>>>>>>>>>>
>>>>>>>>>>> Both of them loop when their halt decider returns {halts} and
>>>>>>>>>>> both halt
>>>>>>>>>>> when their halt decider returns {non-halting}. Both of them
>>>>>>>>>>> continue to
>>>>>>>>>>> call the halt decider in recursive simulation until their
>>>>>>>>>>> halt decider
>>>>>>>>>>> stops simulating them.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, so since the Halt Decider must have a defined behavior
>>>>>>>>>> when given them as an input, that defined behavior will always
>>>>>>>>>> be wrong, because no matter how you define your H, the
>>>>>>>>>> machines will act the other way. This is what proves that
>>>>>>>>>> there can't be a decider that gets all input right.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I did not say that precisely enough.
>>>>>>>>>
>>>>>>>>> Both of the simulated inputs [WOULD] loop if their
>>>>>>>>> corresponding halt
>>>>>>>>> decider [WOULD] return {halts} to them and [WOULD] halt loop if
>>>>>>>>> their
>>>>>>>>> corresponding halt decider [WOULD] return {non-halting} to them
>>>>>>>>> yet the
>>>>>>>>> actual case is that they remain stuck in recursive simulation
>>>>>>>>> until
>>>>>>>>> their corresponding halt decider stops simulating them.
>>>>>>>>>
>>>>>>>>> Thus as you admitted for the H/D pair also applies to the
>>>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly
>>>>>>>>> terminate
>>>>>>>>> normally because it remains stuck in recursive simulation until
>>>>>>>>> the
>>>>>>>>> simulation is terminated *IN BOTH CASES*
>>>>>>>>
>>>>>>>> You seem to be acting like the HBO Westworld character Bernard
>>>>>>>> that was
>>>>>>>> a robot (AKA host) was almost perfectly a very smart human
>>>>>>>> except that
>>>>>>>> his brain was hard-wired to not be able to "see" a specific door.
>>>>>>>>
>>>>>>>> Then, once they're inside the dark house where Ford's robotic
>>>>>>>> family
>>>>>>>> lives, Theresa asks what's behind one of the doors. "What door?"
>>>>>>>> Bernard
>>>>>>>> asks, and that's when you know he's a host as well. The door is
>>>>>>>> plain as
>>>>>>>> day, even in the dark, and he's been there before. And yet, he
>>>>>>>> couldn't
>>>>>>>> see it.
>>>>>>>>
>>>>>>>> https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
>>>>>>>>
>>>>>>>
>>>>>>> So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in
>>>>>>> their execution path?
>>>>>>>
>>>>>>> You claim they differ, so show it.
>>>>>>>
>>>>>>
>>>>>> If you really do know software engineering then you already know
>>>>>> on the
>>>>>> basis that you already agreed that D simulated by H cannot terminate
>>>>>> normally.
>>>>>>
>>>>>
>>>>> Yes, but the question isn't what does the (partial) simulation by H
>>>>> show, but what does the machine repesented by the input do.
>>>>>
>>>>> Since H doesn't simulate all of the behavior of D, its simulation
>>>>> doesn't directly prove that answer.
>>>>>
>>>>>> When you ask a question that you already know the answer to then
>>>>>> you are
>>>>>> only playing head games.
>>>>>
>>>>> Excdpt what the simulation by H does isn't the question that H is
>>>>> supposed to be answering.
>>>>>
>>>>>>
>>>>>>> That, or you are claiming that a "Correct Simulation" can differ
>>>>>>> from the actual machine behavior, despite that going against the
>>>>>>> definition.
>>>>>>>
>>>>>>
>>>>>> You already admitted that D simulated by H never terminates normally.
>>>>>> Thus you knew that H is correct to abort its simulation of D to
>>>>>> prevent
>>>>>> its own infinite execution.
>>>>>
>>>>> H is allowed to abort its simulation for any reason its programmer
>>>>> wants. It still needs to give the right answer to be correct, and
>>>>> that answer needs to describe the behavior of directly running the
>>>>> machine given an input.
>>>>>
>>>>> Since H(D,D) has been said to return 0, we can by simple
>>>>> inspection, and verify by actually running it, see that D(D) will
>>>>> Halt, which means that H's answer is just wrong.
>>>>>
>>>>> It might be a correct POOP decider, but only you seem interested in
>>>>> your POOP.
>>>>>
>>>>>>
>>>>>> The reason that I did this concretely in C is the there is no wiggle
>>>>>> room of ambiguity to deny what is actually occurring.
>>>>
>>>> My way results in a halt decider that recognizes the actual behavior of
>>>> the actual input so that it doesn't get stuck in recursive simulation.
>>>
>>> No, becase the ACTUAL BEHAVIOR of the machine in question is what it
>>> does when actually run.
>> You keep insisting on staying out-of-sync by one recursive invocation.
>>
>> Can D correctly simulated by H terminate normally?
>
> Why does that matter?
>
> Since H is being asked about the actual execution of D(D).

On 5/24/23 12:09 PM, olcott wrote:
> On 5/24/2023 10:57 AM, Richard Damon wrote:
>> On 5/24/23 11:47 AM, olcott wrote:
>>> On 5/23/2023 7:38 PM, Richard Damon wrote:
>>>> On 5/23/23 9:50 AM, olcott wrote:
>>>>> On 5/23/2023 6:44 AM, Richard Damon wrote:
>>>>>> On 5/22/23 11:31 PM, olcott wrote:
>>>>>>> On 5/22/2023 10:12 PM, Richard Damon wrote:
>>>>>>>> On 5/22/23 10:49 PM, olcott wrote:
>>>>>>>>> On 5/22/2023 9:27 PM, olcott wrote:
>>>>>>>>>> On 5/22/2023 9:02 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/22/23 9:33 PM, olcott wrote:
>>>>>>>>>>>> On 5/22/2023 6:22 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/22/23 10:22 AM, olcott wrote:
>>>>>>>>>>>>>> On 5/21/2023 2:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> 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:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, it is wrong because the question asks about the
>>>>>>>>>>>>>>> actual machine, and that halts, so the right answer is
>>>>>>>>>>>>>>> HALTING.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yet any theory of computation computer scientist knows
>>>>>>>>>>>>>> that a simulation
>>>>>>>>>>>>>> of N steps by a UTM does provide that actual behavior of
>>>>>>>>>>>>>> the actual
>>>>>>>>>>>>>> input to this UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, only if the machine reaches a final state in that Nth
>>>>>>>>>>>>> Step.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You just don't understand what a UTM is or what it does.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> They also know that when the input to this UTM is defined
>>>>>>>>>>>>>> to have a
>>>>>>>>>>>>>> pathological relationship to this UTM that this changes
>>>>>>>>>>>>>> the behavior of
>>>>>>>>>>>>>> this correctly simulated input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, a UTM simulation is only correct if it exactly
>>>>>>>>>>>>> matches the FULL b4ehavior of the machine it is looking at.
>>>>>>>>>>>>> That is its DEFINITION.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe I should begin my paper with this self-evident truth
>>>>>>>>>>>>>> before
>>>>>>>>>>>>>> proceeding to the notion of a simulating halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, do that, so anyone who actually understand the theory
>>>>>>>>>>>>> knows from that start that you are a crackpot.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In any case the perfect isomorphism between H/D and
>>>>>>>>>>>>>> embedded_H / ⟨Ĥ⟩
>>>>>>>>>>>>>> already fully proves this point.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Why, since neither H or embedded_H are actually UTMs, and
>>>>>>>>>>>>> it is establishied that both of them declare their input to
>>>>>>>>>>>>> be non-halting when the machine they are given the
>>>>>>>>>>>>> description of Halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *Clearly you are clueless about what the term isomorphism
>>>>>>>>>>>> means*
>>>>>>>>>>>> Both D and ⟨Ĥ⟩ have the exact same form in that both D and
>>>>>>>>>>>> ⟨Ĥ⟩ attempt to
>>>>>>>>>>>> do the opposite of whatever their corresponding halt decider
>>>>>>>>>>>> determines.
>>>>>>>>>>>>
>>>>>>>>>>>> Both of them loop when their halt decider returns {halts}
>>>>>>>>>>>> and both halt
>>>>>>>>>>>> when their halt decider returns {non-halting}. Both of them
>>>>>>>>>>>> continue to
>>>>>>>>>>>> call the halt decider in recursive simulation until their
>>>>>>>>>>>> halt decider
>>>>>>>>>>>> stops simulating them.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, so since the Halt Decider must have a defined behavior
>>>>>>>>>>> when given them as an input, that defined behavior will
>>>>>>>>>>> always be wrong, because no matter how you define your H, the
>>>>>>>>>>> machines will act the other way. This is what proves that
>>>>>>>>>>> there can't be a decider that gets all input right.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I did not say that precisely enough.
>>>>>>>>>>
>>>>>>>>>> Both of the simulated inputs [WOULD] loop if their
>>>>>>>>>> corresponding halt
>>>>>>>>>> decider [WOULD] return {halts} to them and [WOULD] halt loop
>>>>>>>>>> if their
>>>>>>>>>> corresponding halt decider [WOULD] return {non-halting} to
>>>>>>>>>> them yet the
>>>>>>>>>> actual case is that they remain stuck in recursive simulation
>>>>>>>>>> until
>>>>>>>>>> their corresponding halt decider stops simulating them.
>>>>>>>>>>
>>>>>>>>>> Thus as you admitted for the H/D pair also applies to the
>>>>>>>>>> embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly
>>>>>>>>>> terminate
>>>>>>>>>> normally because it remains stuck in recursive simulation
>>>>>>>>>> until the
>>>>>>>>>> simulation is terminated *IN BOTH CASES*
>>>>>>>>>
>>>>>>>>> You seem to be acting like the HBO Westworld character Bernard
>>>>>>>>> that was
>>>>>>>>> a robot (AKA host) was almost perfectly a very smart human
>>>>>>>>> except that
>>>>>>>>> his brain was hard-wired to not be able to "see" a specific door.
>>>>>>>>>
>>>>>>>>> Then, once they're inside the dark house where Ford's robotic
>>>>>>>>> family
>>>>>>>>> lives, Theresa asks what's behind one of the doors. "What
>>>>>>>>> door?" Bernard
>>>>>>>>> asks, and that's when you know he's a host as well. The door is
>>>>>>>>> plain as
>>>>>>>>> day, even in the dark, and he's been there before. And yet, he
>>>>>>>>> couldn't
>>>>>>>>> see it.
>>>>>>>>>
>>>>>>>>> https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in
>>>>>>>> their execution path?
>>>>>>>>
>>>>>>>> You claim they differ, so show it.
>>>>>>>>
>>>>>>>
>>>>>>> If you really do know software engineering then you already know
>>>>>>> on the
>>>>>>> basis that you already agreed that D simulated by H cannot terminate
>>>>>>> normally.
>>>>>>>
>>>>>>
>>>>>> Yes, but the question isn't what does the (partial) simulation by
>>>>>> H show, but what does the machine repesented by the input do.
>>>>>>
>>>>>> Since H doesn't simulate all of the behavior of D, its simulation
>>>>>> doesn't directly prove that answer.
>>>>>>
>>>>>>> When you ask a question that you already know the answer to then
>>>>>>> you are
>>>>>>> only playing head games.
>>>>>>
>>>>>> Excdpt what the simulation by H does isn't the question that H is
>>>>>> supposed to be answering.
>>>>>>
>>>>>>>
>>>>>>>> That, or you are claiming that a "Correct Simulation" can differ
>>>>>>>> from the actual machine behavior, despite that going against the
>>>>>>>> definition.
>>>>>>>>
>>>>>>>
>>>>>>> You already admitted that D simulated by H never terminates
>>>>>>> normally.
>>>>>>> Thus you knew that H is correct to abort its simulation of D to
>>>>>>> prevent
>>>>>>> its own infinite execution.
>>>>>>
>>>>>> H is allowed to abort its simulation for any reason its programmer
>>>>>> wants. It still needs to give the right answer to be correct, and
>>>>>> that answer needs to describe the behavior of directly running the
>>>>>> machine given an input.
>>>>>>
>>>>>> Since H(D,D) has been said to return 0, we can by simple
>>>>>> inspection, and verify by actually running it, see that D(D) will
>>>>>> Halt, which means that H's answer is just wrong.
>>>>>>
>>>>>> It might be a correct POOP decider, but only you seem interested
>>>>>> in your POOP.
>>>>>>
>>>>>>>
>>>>>>> The reason that I did this concretely in C is the there is no wiggle
>>>>>>> room of ambiguity to deny what is actually occurring.
>>>>>
>>>>> My way results in a halt decider that recognizes the actual
>>>>> behavior of
>>>>> the actual input so that it doesn't get stuck in recursive simulation.
>>>>
>>>> No, becase the ACTUAL BEHAVIOR of the machine in question is what it
>>>> does when actually run.
>>> You keep insisting on staying out-of-sync by one recursive invocation.
>>>
>>> Can D correctly simulated by H terminate normally?
>>
>> Why does that matter?
>>
>> Since H is being asked about the actual execution of D(D).
>
> *This is factually incorrect*
> H is only being asked about the behavior of its input.