On 2/15/2022 10:37 PM, Richard Damon wrote:
> On 2/15/22 10:39 PM, olcott wrote:
>> On 2/15/2022 9:14 PM, Richard Damon wrote:
>>> On 2/15/22 9:50 PM, olcott wrote:
>>>> On 2/15/2022 8:49 PM, olcott wrote:
>>>>> On 2/15/2022 8:07 PM, Richard Damon wrote:
>>>>>> On 2/15/22 8:17 PM, olcott wrote:
>>>>>>> On 2/15/2022 5:40 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 2/15/22 11:49 AM, olcott wrote:
>>>>>>>>> On 2/14/2022 5:49 AM, Richard Damon wrote:
>>>>>>>>>> On 2/13/22 10:30 PM, olcott wrote:
>>>>>>>>>>> On 2/13/2022 7:27 PM, Richard Damon wrote:
>>>>>>>>>>>> On 2/13/22 7:26 PM, olcott wrote:
>>>>>>>>>>>>> On 2/13/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 2/13/22 6:08 PM, olcott wrote:
>>>>>>>>>>>>>>> On 2/13/2022 4:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 2/13/22 5:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 2/13/2022 3:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 2/13/22 4:24 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 2/13/2022 3:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 2/13/22 3:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 2/13/2022 1:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2/13/22 2:43 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2/13/2022 11:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 2/13/22 9:38 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2/13/2022 5:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/13/22 12:54 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 8:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 9:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 7:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 8:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 6:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 7:37 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 6:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 6:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 5:39 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 5:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 8:41 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 9:08 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 6:49 AM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 12:01 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 10:50 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/22 11:36 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 6:58 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/22 7:52 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 6:17 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/22 7:10 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 5:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/22 10:20 AM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 5:36 AM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/22 11:39 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/2022 10:20
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/22 10:58 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/2022 6:02
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/22 9:18
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>   > I explain how
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning of my
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words and you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagree on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> failure to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning of these
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you CLAIM to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explain based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words, but use the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS PROVEN TO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BE COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY ON
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE BASIS OF THE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF ITS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WORDS:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines in a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite number of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach the final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then it can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decided, then yes.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it has been
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shown, by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> construction
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> method of H^ that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> goes to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and Halts,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and thus by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, then we also
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have that UTM <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> will halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep getting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> confused between
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> two things:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) The execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Ĥ ⟨Ĥ⟩ versus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (we only look at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the latter).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, YOU qre confused.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> By the definioon of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> how to build H^,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H MUST be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EXACTLY the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm as H,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it is specifically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not allowed to be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H must have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> appended to its Ĥ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state and H is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to have such
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a loop appended to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its H.qy state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which is OUTSIDE the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> algorithm of H itself,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and doesn't affect the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of H in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding to go from Q0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to Qy/Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider bases it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function is being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called with the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs the difference
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> between H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H can change
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior. A string
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comparison between the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H and embedded_H yields
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it can't, not and be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a COMPUTATION.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You obviously don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words, so you are just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computation means for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ALL copoies, Same input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> leads to Same Output.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that it is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an exact copy makes a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difference.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it IS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not determine that itself
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is being called multiple
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> times with the same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H does determine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that itself is called
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> multiple times with the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same input because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> strcmp(H, embedded_H != 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does't have a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'representation' of itself
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to use to make that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comparison, so that is just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> more of your Fairy Dust
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Powered Unicorn stuff.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It can very easily have a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of itself,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that only requires that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has access to its own machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> First, Turing Machines DON'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have access to their own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description, unless it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has been provided as an input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You said that this was impossible.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you are agreeing that they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't? Or do you just not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the logic.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am agreeing that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> contradicted yourself.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> How, by saying that the only way a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing Machine can have a copy of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its representation is for it to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> given (and H is defined in a way
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it can't be given as an extra
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input)?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No appended infinite loop making H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and embedded_H the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* H.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Except that the infinite loop isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> part of the copy of H in H^, it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something ADD to it, which only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has/affects behavior AFTER H makes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So another words hypothetical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> examples get you so confused you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally lose track of everything.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What 'Hypothetical' are you referencing.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what I mean when I say that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> hardly pay any attention at all.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is the hypothetical that I am
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> referencing:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No appended infinite loop making H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what do you mean by that?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When I redefine Ĥ to become Ḧ by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminating its infinite loop, I probably
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mean: {I redefine Ĥ to become Ḧ by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminating its infinite loop}.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which does what? Since if you aren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about Linz's H^, your results
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't mean anything for the Halting Problem.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It provides a bridge of understanding to my
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HP refutation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The key skill that I have applied
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> throughout my career is eliminating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "inessential complexity" (1999 Turing award
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> winner Fred Brooks) to make   enormously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> difficult problems as simple as possible.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/No_Silver_Bullet
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But if you eliminate KEY ASPECTS then you
>>>>>>>>>>>>>>>>>>>>>>>>>>>> aren't talking about what you need to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It is just like learning arithmetic before
>>>>>>>>>>>>>>>>>>>>>>>>>>> attacking algebra.
>>>>>>>>>>>>>>>>>>>>>>>>>>> It lays the foundation of prerequisites for
>>>>>>>>>>>>>>>>>>>>>>>>>>> my actual rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Just beware that if you make a statement that
>>>>>>>>>>>>>>>>>>>>>>>>>> is only true for a limited case and don't
>>>>>>>>>>>>>>>>>>>>>>>>>> explicitly state so, pointing that out is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>> a 'Dishonest Dodge'.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Since it is know that you are working on
>>>>>>>>>>>>>>>>>>>>>>>>>> trying to prove that a Unicorn exists, what
>>>>>>>>>>>>>>>>>>>>>>>>>> you are saying WILL be looked at in a light
>>>>>>>>>>>>>>>>>>>>>>>>>> anticipating where you are going.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Also remember that showing a rule happens to
>>>>>>>>>>>>>>>>>>>>>>>>>> be correct for one case, doesn't prove that it
>>>>>>>>>>>>>>>>>>>>>>>>>> will be for a different case.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You have gone through all of this before, and
>>>>>>>>>>>>>>>>>>>>>>>>>> it came for nothing, but if this is how you
>>>>>>>>>>>>>>>>>>>>>>>>>> want to spend your last days, knock yourself out.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I think that you already understand that
>>>>>>>>>>>>>>>>>>>>>>>>> With Ĥ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // this path
>>>>>>>>>>>>>>>>>>>>>>>>> is never taken
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> making Ḧ ⟨Ḧ⟩ an equivalent computation
>>>>>>>>>>>>>>>>>>>>>>>>> Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>>>>>>>>>>>>>>>>>>>>>> Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And, as seems common with your arguments, you
>>>>>>>>>>>>>>>>>>>>>>>> keep on forgetting the CONDITIONS on each line.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> is
>>>>>>>>>>>>>>>>>>>>>>>> H^.q0 <H^> -> H^.Qx <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>> Then
>>>>>>>>>>>>>>>>>>>>>>>> H^.Qx <H^> <H^> -> H^.Qy -> ∞ IF and only if H
>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> -> H.Qy and
>>>>>>>>>>>>>>>>>>>>>>>> H^.Qx <H^> <H^> -> H^.Qn If and ohly if H <H^>
>>>>>>>>>>>>>>>>>>>>>>>> <H^> => H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If you stipulate that H <H^> <H^> will never go
>>>>>>>>>>>>>>>>>>>>>>>> to H.Qy, then the behavior on that path can be
>>>>>>>>>>>>>>>>>>>>>>>> changed with no effect.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Without the If and only if clauses, the initial
>>>>>>>>>>>>>>>>>>>>>>>> description is incorrect because it is incomplete.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So, WITH THE STIPULATION THAT H won't go to H.Qy
>>>>>>>>>>>>>>>>>>>>>>>> for either version, then changing H^ to the H"
>>>>>>>>>>>>>>>>>>>>>>>> that omits to loop is an equivalence, but ONLY
>>>>>>>>>>>>>>>>>>>>>>>> under that stipulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This of course shows that H will be wrong about
>>>>>>>>>>>>>>>>>>>>>>>> H", as H" will ALWAYS Halt if H answers, and H
>>>>>>>>>>>>>>>>>>>>>>>> not answering is always wrong. Thus H will
>>>>>>>>>>>>>>>>>>>>>>>> either be wrong for not answering or giving the
>>>>>>>>>>>>>>>>>>>>>>>> wrong answer.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I am only making two versions of input to H:
>>>>>>>>>>>>>>>>>>>>>>> (1) Ĥ WITH an appended infinite loop
>>>>>>>>>>>>>>>>>>>>>>> (2) Ḧ WITHOUT an appended infinite loop
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Only this is being examined:
>>>>>>>>>>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Right, but the conclusion that H" is 'equivalent'
>>>>>>>>>>>>>>>>>>>>>> to H^ is only true (if you mean equivalent in the
>>>>>>>>>>>>>>>>>>>>>> sense that they compute the same function) if it
>>>>>>>>>>>>>>>>>>>>>> is the case that neither of H <H^> <H^> or H <H">
>>>>>>>>>>>>>>>>>>>>>> <H"> go to H.Qy.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Good.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Unless you want to indicate some other definition
>>>>>>>>>>>>>>>>>>>>>> of 'equivalent' you using (that could be proper to
>>>>>>>>>>>>>>>>>>>>>> do so here), you need to include the conditions
>>>>>>>>>>>>>>>>>>>>>> under which the statement is true.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ḧ.qn
>>>>>>>>>>>>>>>>>>>>>    and
>>>>>>>>>>>>>>>>>>>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>>>>>>>>>>>>>>>>    nd
>>>>>>>>>>>>>>>>>>>>> H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Problem, embedded_H / H need to transition to a
>>>>>>>>>>>>>>>>>>>> state in H, not some other machine.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> As soon as we append an infinite loop to H.y is it no
>>>>>>>>>>>>>>>>>>> longer H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This is where you are showing your lack of
>>>>>>>>>>>>>>>>>> understanding of Turing Machines.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> NO ONE has said that the machine where we added the
>>>>>>>>>>>>>>>>>> loop is still the machine H, in fact, Linz calls that
>>>>>>>>>>>>>>>>>> machine H', but H' CONTAINS a complete copy of H, and
>>>>>>>>>>>>>>>>>> that copy will still act exactly like the original H
>>>>>>>>>>>>>>>>>> to the point where it gets to the stat Qy.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This ability to compose machines of copies of other
>>>>>>>>>>>>>>>>>> machines is basically like the concept of calling
>>>>>>>>>>>>>>>>>> subroutines (even if it is implemented differently)
>>>>>>>>>>>>>>>>>> and is fundamental to the design and analysis of
>>>>>>>>>>>>>>>>>> Turing Macines.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Would you have a problem saying the subroutine H is no
>>>>>>>>>>>>>>>>>> longer the subroutine H if one function just calls H
>>>>>>>>>>>>>>>>>> and returns while a second calls H and conditionally
>>>>>>>>>>>>>>>>>> loops? Yes, the whole program is not H, but the
>>>>>>>>>>>>>>>>>> subroutine H is still there and will behave exactly
>>>>>>>>>>>>>>>>>> like it used to in both of the cases.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> One way to map a Turing Machine to ordinary software
>>>>>>>>>>>>>>>>>> is to think of the Q0 state (or whatever is the
>>>>>>>>>>>>>>>>>> 'starting' state of the Turing machine) as the entry
>>>>>>>>>>>>>>>>>> point for the function, and the Halting States of the
>>>>>>>>>>>>>>>>>> Turing Machine as retrun stateents which return a
>>>>>>>>>>>>>>>>>> value indicating what state the machine ended in.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus the modifications Linz has done to H are nothing
>>>>>>>>>>>>>>>>>> more that building H^ as mostly a call to H, with code
>>>>>>>>>>>>>>>>>> before the call to manipulate the tape to add the
>>>>>>>>>>>>>>>>>> second copy, and code after the return to loop forever
>>>>>>>>>>>>>>>>>> if H returns the 'Halting' answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The Machine/Subroutine H has not been touched at all.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> My point is that Ĥ ⟨Ĥ⟩ is equivalent to Ḧ ⟨Ḧ⟩
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And my point is that they are only equivalent in the
>>>>>>>>>>>>>>>> normal sense of the word if neither of H <H^> <H^> and H
>>>>>>>>>>>>>>>> <H"> <H"> go to H.Qy
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Without that qualification, it is a false statement.
>>>>>>>>>>>>>>>> PERIOD.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> They are equivalent in that neither can possibly go to
>>>>>>>>>>>>>>> their q.y state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> THAT is incorrect without the same
>>>>>>>>>>>>>> qualification/assumption/stipulation, the H doesn't go to Qy.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H was a white cat detector and you presented H with a
>>>>>>>>>>>>> black cat would it say "yes" ?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But we aren't talking about a 'detector'
>>>>>>>>>>>
>>>>>>>>>>> Sure we are.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then you don't know what you are talking about (and showing
>>>>>>>>>> your dishonesty by your clipping).
>>>>>>>>>>
>>>>>>>>>> THe claim that H^ and H" are equivilent machines has NOTHING
>>>>>>>>>> to do with there being a 'Detector' but do they behave exactly
>>>>>>>>>> the same.
>>>>>>>>> So in other words you are disavowing that both ⟨Ĥ⟩ and ⟨Ḧ⟩ have
>>>>>>>>> a copy of H embedded within them ?
>>>>>>>>>
>>>>>>>>> A halt detector is the same idea as a halt decider yet a halt
>>>>>>>>> detector need not get every input correctly. Every input that
>>>>>>>>> the halt detector gets correctly is in the domain of the
>>>>>>>>> computable function that it implements.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, they have a copy of the Halt Detector H in them, and unless
>>>>>>>> you are willing to stipulate that H will not go to H.Qy when
>>>>>>>> given H^ or H" as an input, then you can not show that those
>>>>>>>> machines are equivalent.
>>>>>>>
>>>>>>> If the simulating halt decider H cannot possibly go to H.qy on a
>>>>>>> specific input then any such stipulation would be redundant for
>>>>>>> this input.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> So why do you resist it?
>>>>>>
>>>>>> What is wrong with stipulating as a requirement something you
>>>>>> 'know' to be true?
>>>>>>
>>>>>> The only reason I can see for you to object to listing that
>>>>>> requirement. is that at some point you are going to want to
>>>>>> violate that requirement.
>>>>>
>>>>> Specifically because it was redundant.
>>>>> embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> It does not take a genius to know that when
>>>>> embedded_H transitions to H.qn it does not transition to H.qn
>>>>     embedded_H transitions to H.qn it does not transition to H.qy
>>>>
>>>
>>> So, are you stating as a fact that embedded_H <H^> <H^> and
>>> embedded_H <H"> <H"> both as a matter of DEFINITION go to H.Qn?
>>>
>>
>> For H to be correct then on the above specified inputs they must both
>> go to H.qn.
>>
>>
>
> But, by DEFINITION that is the WRONG answer.
>
> DEFINITION of a Correct Halt Decider:
>
> A) H <M> w goes to H.Qy if M w Halts, and to H.Qn if M w never Halts.
I am only talking about these two:
embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Whenever any embedded_H must abort the simulation of its input to
prevent the infinitely nested simulation of this input the entire nested
simulation sequence specifies infinitely nested simulation. This makes a
transition to H.qn necessarily correct in this case.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer