On 2/16/2022 6:55 AM, Richard Damon wrote:
> On 2/16/22 7:37 AM, olcott wrote:
>> 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.
>>
>
> Right, the NESTED simulation, but NOT the H^ / H" that is USING that
> embededeed_H, and it is THAT machine that defines the CORRECT answer for H.
>

That problem is that you are flat out wrong about this.
embedded_H IS NOT REPORTING ON ITS OWN BEHAVIOR
THUS NOT REPORTING ON Ĥ ⟨Ĥ⟩

--
Copyright 2021 Pete Olcott

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