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.

It seems that you do not beleive that embedded_H and H must do the same
thing. Prove that for an embedded_H that actually meets its requirments
and be famous.

Given that embedded_H <H"> <H"> -> Qn (with whatever prefix you want to
give it) we also have that H" <H"> will end up at H".Qn by the
definition of its construction.

DO YOU AGREE? (or are you lying about meeting the requrements of Linz)

If H"<H"> goes to H".Qn, it will HALT, CORRECT?

(or are you using some incorrect defintion of Halting).

If H" <H"> Halts, then BY DEFINTION the correct answer for

H <H"> <H"> would be H.Qy, since the requirement on H was that H applied
to <M> w goes to H.Qy if M applied to w halts. Since H" applied to <H">
Halts, then H <H"> <H"> must go to H.Qy to be correct.

What is wrong with that logic based on the simple DEFINTION of a Halt
Decider.

Since embedded_H is just a copy of H (not even modified at Qy for H")
then embedded_H must behave the same as H for any given input.

CORRECT?

THus since embedded_H went to H.Qn, so must H, so H was WRONG.

FAIL.