On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/26/2021 3:55 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> The following is the exact Linz Ĥ applied to its own Turing machine
>>>> description except that the infinite loop appended to the Ĥ.qy path
>>>> has been removed.
>>>>
>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>
>>>> As the Linz text says a copy of the Linz H is at Ḧ.qx above.
>>>>
>>>> It is known that the UTM simulation of a Turing machine description is
>>>> computationally equivalent to the direct execution of the same
>>>> machine. This allows the copy of the Linz H to base its halt status
>>>> decision on the behavior of the UTM simulation of its input.
>>>>
>>>> Ben's notational convention
>>>> H.q0 wM w ⊢* H.qy // iff UTM(wM, w) halts
>>>> H.q0 wM w ⊢* H.qn // iff UTM(wM, w) does not halt
>>> Nope, not my notation. It seems like a small change but I think it is
>>> very revealing: I did not use a comment symbol. The condition I wrote
>>> is a mathematical constraint on what goes in front like "if x is prime".
>>> The fact that you use a comment is not, I think, accidental. You say
>>> something (that happens to be incorrect) about how H might work with a
>>> UTM, and you use the comment notation to back it up. It's as if you
>>> think the comment explains what H is doing (as one would use a comment
>>> in a program) whereas, in fact, its a constraint that shows it can't
>>> exist.
>>> So, please don't use a comment symbol and attribute the notation to me.
>>> The constraint is not a comment about what is going on.
>>>
>>>> The copy of H at Ḧ.qx computes the mapping from ⟨Ḧ⟩ ⟨Ḧ⟩ to final states Ḧ.qy or Ḧ.qn on the basis of the behavior of the UTM simulation of these
>>>> inputs.
>>> But Linz's H (and therefore your Ḧ) covers more TMs that this. Basing
>>> transition to qy or qn on the behaviour on a UTM is only one way that a
>>> decider can fail. The proof covers TM that fail for reasons you have
>>> not even thought of yet.
>>>
>>>> The embedded copy of H performs a UTM simulation of its input until:
>>> But Linz does not assume there is any simulation going on, and my
>>> re-writing of the constraint does not assume that either. The switch to
>>> writing // reveals a deep misunderstand about what I wrote and about
>>> what Linz's constraints mean.
>>>
>>>> (a) Its input halts on its own, then it transitions to Ḧ.qy.
>>>>
>>>> (b) It determines that the UTM simulation of its input would never
>>>> halt on its own, then it aborts its simulation and transitions to
>>>> Ḧ.qn.
>>>
>>> That's a halt decider. The determination in (b) is provably impossible
>>> for any TM to make.
>>
>> Did you even notice that the infinite loop has been removed?
>
> Of course I did. Did you read what I wrote? You say nothing in the
> least bit relevant to my remarks in this reply.
>
> But for me, the main point is that if you use a comment symbol where a
> mathematical constraint should be, please /don't/ say it's my notation.
>

I can't get Richard to understand that this:
H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt

Means this:
We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
would be if the embedded H was replaced by a UTM.

When applied to this:
Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn

--
Copyright 2021 Pete Olcott

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

On 12/26/21 8:41 PM, olcott wrote:
> On 12/26/2021 7:31 PM, Richard Damon wrote:
>> On 12/26/21 8:24 PM, olcott wrote:
>>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 12/26/2021 3:55 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> The following is the exact Linz Ĥ applied to its own Turing machine
>>>>>>> description except that the infinite loop appended to the Ĥ.qy path
>>>>>>> has been removed.
>>>>>>>
>>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>>>
>>>>>>> As the Linz text says a copy of the Linz H is at Ḧ.qx above.
>>>>>>>
>>>>>>> It is known that the UTM simulation of a Turing machine
>>>>>>> description is
>>>>>>> computationally equivalent to the direct execution of the same
>>>>>>> machine.  This allows the copy of the Linz H to base its halt status
>>>>>>> decision on the behavior of the UTM simulation of its input.
>>>>>>>
>>>>>>> Ben's notational convention
>>>>>>> H.q0 wM w ⊢* H.qy // iff UTM(wM, w) halts
>>>>>>> H.q0 wM w ⊢* H.qn // iff UTM(wM, w) does not halt
>>>>>> Nope, not my notation.  It seems like a small change but I think
>>>>>> it is
>>>>>> very revealing: I did not use a comment symbol.  The condition I
>>>>>> wrote
>>>>>> is a mathematical constraint on what goes in front like "if x is
>>>>>> prime".
>>>>>> The fact that you use a comment is not, I think, accidental.  You say
>>>>>> something (that happens to be incorrect) about how H might work
>>>>>> with a
>>>>>> UTM, and you use the comment notation to back it up.  It's as if you
>>>>>> think the comment explains what H is doing (as one would use a
>>>>>> comment
>>>>>> in a program) whereas, in fact, its a constraint that shows it can't
>>>>>> exist.
>>>>>> So, please don't use a comment symbol and attribute the notation
>>>>>> to me.
>>>>>> The constraint is not a comment about what is going on.
>>>>>>
>>>>>>> The copy of H at Ḧ.qx computes the mapping from ⟨Ḧ⟩ ⟨Ḧ⟩ to final
>>>>>>> states Ḧ.qy or Ḧ.qn on the basis of the behavior of the UTM
>>>>>>> simulation of these
>>>>>>> inputs.
>>>>>> But Linz's H (and therefore your Ḧ) covers more TMs that this.
>>>>>> Basing
>>>>>> transition to qy or qn on the behaviour on a UTM is only one way
>>>>>> that a
>>>>>> decider can fail.  The proof covers TM that fail for reasons you have
>>>>>> not even thought of yet.
>>>>>>
>>>>>>> The embedded copy of H performs a UTM simulation of its input until:
>>>>>> But Linz does not assume there is any simulation going on, and my
>>>>>> re-writing of the constraint does not assume that either.  The
>>>>>> switch to
>>>>>> writing // reveals a deep misunderstand about what I wrote and about
>>>>>> what Linz's constraints mean.
>>>>>>
>>>>>>> (a) Its input halts on its own, then it transitions to Ḧ.qy.
>>>>>>>
>>>>>>> (b) It determines that the UTM simulation of its input would never
>>>>>>> halt on its own, then it aborts its simulation and transitions to
>>>>>>> Ḧ.qn.
>>>>>>
>>>>>> That's a halt decider.  The determination in (b) is provably
>>>>>> impossible
>>>>>> for any TM to make.
>>>>>
>>>>> Did you even notice that the infinite loop has been removed?
>>>>
>>>> Of course I did.  Did you read what I wrote?  You say nothing in the
>>>> least bit relevant to my remarks in this reply.
>>>>
>>>> But for me, the main point is that if you use a comment symbol where a
>>>> mathematical constraint should be, please /don't/ say it's my notation.
>>>>
>>>
>>> I can't get Richard to understand that this:
>>>
>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>
>>> Means this:
>>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩ would be if
>>> the embedded H was replaced by a UTM.
>>
>> Where does it say replace by a UTM.
>
> I have to say it that was because you are not smart enough to understand
> that the behavior of the UTM applies to ever nested simulation.
>

FALSE.

WHERE IS THAT STATED?

That implies that H IS a UTM, and thus does not answer.

Remeber, H answers in FINITE time, as opposed to what a UTM does.

FAIL.

Your forgetting that your 'partial' UTM structure can convert a
potentially infinite simulation into a finite machine calling it.

BUILD IT AND SHOW IT.

On 12/26/21 8:55 PM, olcott wrote:
> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/26/2021 3:55 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> The following is the exact Linz Ĥ applied to its own Turing machine
>>>>> description except that the infinite loop appended to the Ĥ.qy path
>>>>> has been removed.
>>>>>
>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>
>>>>> As the Linz text says a copy of the Linz H is at Ḧ.qx above.
>>>>>
>>>>> It is known that the UTM simulation of a Turing machine description is
>>>>> computationally equivalent to the direct execution of the same
>>>>> machine.  This allows the copy of the Linz H to base its halt status
>>>>> decision on the behavior of the UTM simulation of its input.
>>>>>
>>>>> Ben's notational convention
>>>>> H.q0 wM w ⊢* H.qy // iff UTM(wM, w) halts
>>>>> H.q0 wM w ⊢* H.qn // iff UTM(wM, w) does not halt
>>>> Nope, not my notation.  It seems like a small change but I think it is
>>>> very revealing: I did not use a comment symbol.  The condition I wrote
>>>> is a mathematical constraint on what goes in front like "if x is
>>>> prime".
>>>> The fact that you use a comment is not, I think, accidental.  You say
>>>> something (that happens to be incorrect) about how H might work with a
>>>> UTM, and you use the comment notation to back it up.  It's as if you
>>>> think the comment explains what H is doing (as one would use a comment
>>>> in a program) whereas, in fact, its a constraint that shows it can't
>>>> exist.
>>>> So, please don't use a comment symbol and attribute the notation to me.
>>>> The constraint is not a comment about what is going on.
>>>>
>>>>> The copy of H at Ḧ.qx computes the mapping from ⟨Ḧ⟩ ⟨Ḧ⟩ to final
>>>>> states Ḧ.qy or Ḧ.qn on the basis of the behavior of the UTM
>>>>> simulation of these
>>>>> inputs.
>>>> But Linz's H (and therefore your Ḧ) covers more TMs that this.  Basing
>>>> transition to qy or qn on the behaviour on a UTM is only one way that a
>>>> decider can fail.  The proof covers TM that fail for reasons you have
>>>> not even thought of yet.
>>>>
>>>>> The embedded copy of H performs a UTM simulation of its input until:
>>>> But Linz does not assume there is any simulation going on, and my
>>>> re-writing of the constraint does not assume that either.  The
>>>> switch to
>>>> writing // reveals a deep misunderstand about what I wrote and about
>>>> what Linz's constraints mean.
>>>>
>>>>> (a) Its input halts on its own, then it transitions to Ḧ.qy.
>>>>>
>>>>> (b) It determines that the UTM simulation of its input would never
>>>>> halt on its own, then it aborts its simulation and transitions to
>>>>> Ḧ.qn.
>>>>
>>>> That's a halt decider.  The determination in (b) is provably impossible
>>>> for any TM to make.
>>>
>>> Did you even notice that the infinite loop has been removed?
>>
>> Of course I did.  Did you read what I wrote?  You say nothing in the
>> least bit relevant to my remarks in this reply.
>>
>> But for me, the main point is that if you use a comment symbol where a
>> mathematical constraint should be, please /don't/ say it's my notation.
>>
>
> I can't get Richard to understand that this:
> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>
> Means this:
> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
> would be if the embedded H was replaced by a UTM.
>
> When applied to this:
> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>

Because it doesn't

FAIL.

olcott <NoOne@NoWhere.com> writes:

> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:

>> But for me, the main point is that if you use a comment symbol where a
>> mathematical constraint should be, please /don't/ say it's my
>> notation.

You appear to have stopped, at least for now.

> I can't get Richard to understand that this:
> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>
> Means this:
> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
> would be if the embedded H was replaced by a UTM.

Because it does not. And since the notation is mine, you don't get to
say what it means. You can ask questions, but that's about it.

> When applied to this:
> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn

When applied to those lines, the conditions become

Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.

and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you
don't need both. The behaviour of Ḧ(⟨Ḧ⟩) would simply be this:

Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qy.

But since no H satisfies the original specification, there is no Ḧ for
this banal fact to apply to.

--
Ben.

On 12/27/2021 8:50 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>
>>> But for me, the main point is that if you use a comment symbol where a
>>> mathematical constraint should be, please /don't/ say it's my
>>> notation.
>
> You appear to have stopped, at least for now.
>
>> I can't get Richard to understand that this:
>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>
>> Means this:
>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
>> would be if the embedded H was replaced by a UTM.
>
> Because it does not. And since the notation is mine, you don't get to
> say what it means. You can ask questions, but that's about it.
>
>> When applied to this:
>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>
> When applied to those lines, the conditions become
>
> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.
>
> and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you

Let's now go back to the original Ĥ applied to ⟨Ĥ⟩

Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.

Unless you assume that the embedded H at Ĥ.qx transitions to Ĥ.qn on the
basis that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt there is no basis to determine
whether or not Ĥ(⟨Ĥ⟩) halts.

--
Copyright 2021 Pete Olcott

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

On 12/27/21 10:45 AM, olcott wrote:
> On 12/27/2021 8:50 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>>
>>>> But for me, the main point is that if you use a comment symbol where a
>>>> mathematical constraint should be, please /don't/ say it's my
>>>> notation.
>>
>> You appear to have stopped, at least for now.
>>
>>> I can't get Richard to understand that this:
>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>
>>> Means this:
>>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
>>> would be if the embedded H was replaced by a UTM.
>>
>> Because it does not.  And since the notation is mine, you don't get to
>> say what it means.  You can ask questions, but that's about it.
>>
>>> When applied to this:
>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>
>> When applied to those lines, the conditions become
>>
>>    Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy  iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
>>    Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn  iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.
>>
>> and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you
>
> Let's now go back to the original Ĥ applied to ⟨Ĥ⟩
>
> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>
> Unless you assume that the embedded H at Ĥ.qx transitions to Ĥ.qn on the
> basis that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt there is no basis to determine
> whether or not Ĥ(⟨Ĥ⟩) halts.
>

So, you admit that it can't be done?

Yes, one way to look at the problem is that there is no way for H to get
enough information to solve the problem, in part, because there is no
solution.

The problem with your statement is it assume a contradiction.

If H^ transitions to H^.qn then we KNOW that UTM(<H^>,<H^>) Halts, not
that it does not halt.

If we guess that UTM(<H^>,<H^>) Halts, and go to H.qy and H^.qy we see
that UTM(<H^>,<H^>) will not halt, and if we guess that UTM(<H^>.<H^>)
does not halt and go to H.qn and H^.qn then we see that UTM(<H^>,<H^>)
will halt.

Thus neither guess is correct, so the only option remaining is for H to
not go to eitehr qy or qn which violates the requirement to decide in
finite time, which shows we have done something wrong, and what we did
wrong was to assume that an H that meet these requirements could exist.

Just because one answer is wrong, doesn't mean the other is right, you
first have to actually PROVE that one of them is correct.

olcott <NoOne@NoWhere.com> writes:

> On 12/27/2021 8:50 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>>
>>>> But for me, the main point is that if you use a comment symbol where a
>>>> mathematical constraint should be, please /don't/ say it's my
>>>> notation.
>> You appear to have stopped, at least for now.
>>
>>> I can't get Richard to understand that this:
>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>
>>> Means this:
>>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
>>> would be if the embedded H was replaced by a UTM.
>> Because it does not. And since the notation is mine, you don't get to
>> say what it means. You can ask questions, but that's about it.
>>
>>> When applied to this:
>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>> When applied to those lines, the conditions become
>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.
>> and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you
>
> Let's now go back to the original Ĥ applied to ⟨Ĥ⟩
>
> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>
> Unless you assume that the embedded H at Ĥ.qx transitions to Ĥ.qn on
> the basis that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt there is no basis to
> determine whether or not Ĥ(⟨Ĥ⟩) halts.

I am not sure you really know what those lines (the formal ones) mean.
If you accept that

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt

is indeed the case for any correctly constructed Ĥ, then the proof is
done and dusted.

UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts if (and only if) Ĥ.q0 ⟨Ĥ⟩ transitions to Ĥ.qn because
Ĥ.qn is the only final state in Ĥ. But Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn only if UTM(⟨Ĥ⟩
⟨Ĥ⟩) does /not/ halt. No TM can behave as these lines specify.

I suspect you are very close to understanding the proof because the
paragraph you wrote is very close to being correct. You are right that
there is no basis to determine whether or not Ĥ(⟨Ĥ⟩) halts. This is
because we assume that the embedded H at Ĥ.qx transitions to Ĥ.qn if and
only of UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt. We assume that because it follows
from the assumption that H is a halt decider. That assumption must be
rejected because of the contradiction that follows from it. As a
result, there is no TM Ĥ and no string ⟨Ĥ⟩ so there is no basis on which
to say anything at all about whether Ĥ(⟨Ĥ⟩) halts.

--
Ben.

On 12/27/2021 6:57 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/27/2021 8:50 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>>>
>>>>> But for me, the main point is that if you use a comment symbol where a
>>>>> mathematical constraint should be, please /don't/ say it's my
>>>>> notation.
>>> You appear to have stopped, at least for now.
>>>
>>>> I can't get Richard to understand that this:
>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>
>>>> Means this:
>>>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
>>>> would be if the embedded H was replaced by a UTM.
>>> Because it does not. And since the notation is mine, you don't get to
>>> say what it means. You can ask questions, but that's about it.
>>>
>>>> When applied to this:
>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>> When applied to those lines, the conditions become
>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.
>>> and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you
>>
>> Let's now go back to the original Ĥ applied to ⟨Ĥ⟩
>>
>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>
>> Unless you assume that the embedded H at Ĥ.qx transitions to Ĥ.qn on
>> the basis that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt there is no basis to
>> determine whether or not Ĥ(⟨Ĥ⟩) halts.
>
> I am not sure you really know what those lines (the formal ones) mean.
> If you accept that
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt
>
> is indeed the case for any correctly constructed Ĥ, then the proof is
> done and dusted.
>

done and dusted seems like gibberish to me.

> UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts if (and only if) Ĥ.q0 ⟨Ĥ⟩ transitions to Ĥ.qn because
> Ĥ.qn is the only final state in Ĥ.

Yes.

>> But Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn only if UTM(⟨Ĥ⟩
> ⟨Ĥ⟩) does /not/ halt. No TM can behave as these lines specify.
>

> I suspect you are very close to understanding the proof because the
> paragraph you wrote is very close to being correct. You are right that
> there is no basis to determine whether or not Ĥ(⟨Ĥ⟩) halts.

I didn't say that. If you get one word of what I say incorrectly that
can totally reverse the meaning of what I said.

The only basis for the copy of H at Ĥ.qx to transition to Ĥ.qn would be
that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.

Because this is based on the embedded H at Ĥ.qx it means that the
UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt criterion measure is applied to every nested
simulation.

Because it applies recursively to every nested simulation we can
simplify the way this is encoded as

What the behavior of Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ would be if the copy of H
at Ĥ.qx was hypothetically replaced by UTM.

Since it is obvious to even Richard that Ĥ applied to ⟨Ĥ⟩ would never
stop running if the embedded copy of H was replaced by a UTM we can
definitively determine that the input to the copy of H at Ĥ.qx never halts.

This makes the transition to Ĥ.qn correct in the same way that we know
for sure that a black is cat is definitely a cat (tautology).

> This is
> because we assume that the embedded H at Ĥ.qx transitions to Ĥ.qn if and
> only of UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt. We assume that because it follows
> from the assumption that H is a halt decider. That assumption must be
> rejected because of the contradiction that follows from it. As a
> result, there is no TM Ĥ and no string ⟨Ĥ⟩ so there is no basis on which
> to say anything at all about whether Ĥ(⟨Ĥ⟩) halts.
>

--
Copyright 2021 Pete Olcott

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

On 12/27/21 8:29 PM, olcott wrote:
> On 12/27/2021 6:57 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/27/2021 8:50 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>>>>
>>>>>> But for me, the main point is that if you use a comment symbol
>>>>>> where a
>>>>>> mathematical constraint should be, please /don't/ say it's my
>>>>>> notation.
>>>> You appear to have stopped, at least for now.
>>>>
>>>>> I can't get Richard to understand that this:
>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>
>>>>> Means this:
>>>>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
>>>>> would be if the embedded H was replaced by a UTM.
>>>> Because it does not.  And since the notation is mine, you don't get to
>>>> say what it means.  You can ask questions, but that's about it.
>>>>
>>>>> When applied to this:
>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>> When applied to those lines, the conditions become
>>>>     Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy  iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
>>>>     Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn  iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.
>>>> and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you
>>>
>>> Let's now go back to the original Ĥ applied to ⟨Ĥ⟩
>>>
>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>>
>>> Unless you assume that the embedded H at Ĥ.qx transitions to Ĥ.qn on
>>> the basis that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt there is no basis to
>>> determine whether or not Ĥ(⟨Ĥ⟩) halts.
>>
>> I am not sure you really know what those lines (the formal ones) mean.
>> If you accept that
>>
>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt
>>
>> is indeed the case for any correctly constructed Ĥ, then the proof is
>> done and dusted.
>>
>
> done and dusted seems like gibberish to me.
>
>> UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts if (and only if) Ĥ.q0 ⟨Ĥ⟩ transitions to Ĥ.qn because
>> Ĥ.qn is the only final state in Ĥ.
>
> Yes.
>
>>> But Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn only if UTM(⟨Ĥ⟩
>> ⟨Ĥ⟩) does /not/ halt.  No TM can behave as these lines specify.
>>
>
>
>> I suspect you are very close to understanding the proof because the
>> paragraph you wrote is very close to being correct.  You are right that
>> there is no basis to determine whether or not Ĥ(⟨Ĥ⟩) halts.
>
> I didn't say that. If you get one word of what I say incorrectly that
> can totally reverse the meaning of what I said.
>
> The only basis for the copy of H at Ĥ.qx to transition to Ĥ.qn would be
> that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.

Then you H isn't a computation, as that can not be universally
determined in finite time.

You don't seem to understand that 'Get the right answer' is NOT a usable
algorithm.

You need to PROVE that you can do that step.

>
> Because this is based on the embedded H at Ĥ.qx it means that the
> UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt criterion measure is applied to every nested
> simulation.

Right, and EVERY nested simulation will Halt when simulated by the UTM,
it just takes longer than H is willing to wait, so H gets the answer
wrong, or H waits forever and doesn't give the answer in finite time.

>
> Because it applies recursively to every nested simulation we can
> simplify the way this is encoded as
>
> What the behavior of Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ would be if the copy of H
> at Ĥ.qx was hypothetically replaced by UTM.

Nope, invalid transform. Unless H IS a UTM, at which point you have
proved it doesn't answer, making that substitution is not valid.

Do you have an actual proof that you can do this?

Even a scholorly reference?

Or do you expect people to just belive you when make statements that are
clearly contradictory, and with absolutely zero basis?

>
> Since it is obvious to even Richard that Ĥ applied to ⟨Ĥ⟩ would never
> stop running if the embedded copy of H was replaced by a UTM we can
> definitively determine that the input to the copy of H at Ĥ.qx never halts.

Right, given the wrong question, you can get an answer, but it is to the
wrong question.

You can determine that Hn^(<Hn^>) is non-haling by a lot of deciders,
but not with Hn, so that case is a failure.

>
> This makes the transition to Ĥ.qn correct in the same way that we know
> for sure that a black is cat is definitely a cat (tautology).

STRAWMAN.

You statement is a flat out lie. Just like saying cats bark because your
poodle you think of as a cat barks.

The fact that you 'best arguement' is this sort of nonsense shows how
bad your case is.

FAIL.

>
>> This is
>> because we assume that the embedded H at Ĥ.qx transitions to Ĥ.qn if and
>> only of UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.  We assume that because it follows
>> from the assumption that H is a halt decider.  That assumption must be
>> rejected because of the contradiction that follows from it.  As a
>> result, there is no TM Ĥ and no string ⟨Ĥ⟩ so there is no basis on which
>> to say anything at all about whether Ĥ(⟨Ĥ⟩) halts.
>>
>
>

On 12/27/21 8:29 PM, olcott wrote:
>
> Since it is obvious to even Richard that Ĥ applied to ⟨Ĥ⟩ would never
> stop running if the embedded copy of H was replaced by a UTM we can
> definitively determine that the input to the copy of H at Ĥ.qx never halts.

I will point out that your use of this sort of mis-use of a quote shows
how bad off your logic is, and how litte people should just trust your
intuition about what is true.

You are obviously out of touch with what is the actual truth about
things and grasping for the tiniest hints of things that can be twisted
to seem to support you in some way.

Maybe if you stopped to actually STUDY what is written about the subject
you would stop making such blatant errors.

olcott <NoOne@NoWhere.com> writes:

> On 12/27/2021 6:57 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/27/2021 8:50 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>>>>
>>>>>> But for me, the main point is that if you use a comment symbol where a
>>>>>> mathematical constraint should be, please /don't/ say it's my
>>>>>> notation.
>>>> You appear to have stopped, at least for now.
>>>>
>>>>> I can't get Richard to understand that this:
>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>
>>>>> Means this:
>>>>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
>>>>> would be if the embedded H was replaced by a UTM.
>>>> Because it does not. And since the notation is mine, you don't get to
>>>> say what it means. You can ask questions, but that's about it.
>>>>
>>>>> When applied to this:
>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>> When applied to those lines, the conditions become
>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.
>>>> and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you
>>>
>>> Let's now go back to the original Ĥ applied to ⟨Ĥ⟩
>>>
>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>>
>>> Unless you assume that the embedded H at Ĥ.qx transitions to Ĥ.qn on
>>> the basis that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt there is no basis to
>>> determine whether or not Ĥ(⟨Ĥ⟩) halts.
>> I am not sure you really know what those lines (the formal ones) mean.
>> If you accept that
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt
>> is indeed the case for any correctly constructed Ĥ, then the proof is
>> done and dusted.
>
> done and dusted seems like gibberish to me.

It's a British idiom meaning "finished" or "all done".

>> UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts if (and only if) Ĥ.q0 ⟨Ĥ⟩ transitions to Ĥ.qn because
>> Ĥ.qn is the only final state in Ĥ.
>
> Yes.
>
>>> But Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn only if UTM(⟨Ĥ⟩
>>> ⟨Ĥ⟩) does /not/ halt. No TM can behave as these lines specify.

You missed this bit.

> The only basis for the copy of H at Ĥ.qx to transition to Ĥ.qn would
> be that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.

Yes. That's why there can't be any TM that behaves this way. I'll try
once more to get you to see it... If UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt, then
Ĥ.q0 ⟨Ĥ⟩ must transition to Ĥ.qn. That's what the constraint means: X
occurs if, and only if, Y. But if Ĥ behaves as it should, and Ĥ.q0 ⟨Ĥ⟩
does indeed transition to Ĥ.qn then, obviously, UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts.

Then again, if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, a correctly behaving Ĥ must
transition to Ĥ.qy and then on to an endless loop. But if that is what
Ĥ.q0 ⟨Ĥ⟩ does, then we know for sure that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.

I really don't think I can help any more than this unless you stop being
so sure of yourself and start to query what you know and what you think
these symbols really mean. I am happy to help with that, but I don't
think you want that sort of help, do you?

--
Ben.

On 12/28/2021 6:22 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/27/2021 6:57 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 12/27/2021 8:50 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>>>>>
>>>>>>> But for me, the main point is that if you use a comment symbol where a
>>>>>>> mathematical constraint should be, please /don't/ say it's my
>>>>>>> notation.
>>>>> You appear to have stopped, at least for now.
>>>>>
>>>>>> I can't get Richard to understand that this:
>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>
>>>>>> Means this:
>>>>>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
>>>>>> would be if the embedded H was replaced by a UTM.
>>>>> Because it does not. And since the notation is mine, you don't get to
>>>>> say what it means. You can ask questions, but that's about it.
>>>>>
>>>>>> When applied to this:
>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>> When applied to those lines, the conditions become
>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.
>>>>> and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you
>>>>
>>>> Let's now go back to the original Ĥ applied to ⟨Ĥ⟩
>>>>
>>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>>>
>>>> Unless you assume that the embedded H at Ĥ.qx transitions to Ĥ.qn on
>>>> the basis that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt there is no basis to
>>>> determine whether or not Ĥ(⟨Ĥ⟩) halts.
>>> I am not sure you really know what those lines (the formal ones) mean.
>>> If you accept that
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt
>>> is indeed the case for any correctly constructed Ĥ, then the proof is
>>> done and dusted.
>>
>> done and dusted seems like gibberish to me.
>
> It's a British idiom meaning "finished" or "all done".
>
>>> UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts if (and only if) Ĥ.q0 ⟨Ĥ⟩ transitions to Ĥ.qn because
>>> Ĥ.qn is the only final state in Ĥ.
>>
>> Yes.
>>
>>>> But Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn only if UTM(⟨Ĥ⟩
>>>> ⟨Ĥ⟩) does /not/ halt. No TM can behave as these lines specify.
>
> You missed this bit.
>
>> The only basis for the copy of H at Ĥ.qx to transition to Ĥ.qn would
>> be that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>
> Yes. That's why there can't be any TM that behaves this way. I'll try
> once more to get you to see it... If UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt, then
> Ĥ.q0 ⟨Ĥ⟩ must transition to Ĥ.qn. That's what the constraint means: X
> occurs if, and only if, Y. But if Ĥ behaves as it should, and Ĥ.q0 ⟨Ĥ⟩
> does indeed transition to Ĥ.qn then, obviously, UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts.

A Fallacy of equivocation error that neither you nor Linz ever noticed.
It is the case that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) never halts ...

When we know that an animal is a cat then it is definitely a cat even if
it barks, wags its tail, and gives birth to puppies.

>
> Then again, if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, a correctly behaving Ĥ must
> transition to Ĥ.qy and then on to an endless loop. But if that is what
> Ĥ.q0 ⟨Ĥ⟩ does, then we know for sure that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>
> I really don't think I can help any more than this unless you stop being
> so sure of yourself and start to query what you know and what you think
> these symbols really mean. I am happy to help with that, but I don't
> think you want that sort of help, do you?
>

--
Copyright 2021 Pete Olcott

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

On 12/28/21 8:08 PM, olcott wrote:
> On 12/28/2021 6:22 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/27/2021 6:57 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 12/27/2021 8:50 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>>>>>>
>>>>>>>> But for me, the main point is that if you use a comment symbol
>>>>>>>> where a
>>>>>>>> mathematical constraint should be, please /don't/ say it's my
>>>>>>>> notation.
>>>>>> You appear to have stopped, at least for now.
>>>>>>
>>>>>>> I can't get Richard to understand that this:
>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>>
>>>>>>> Means this:
>>>>>>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
>>>>>>> would be if the embedded H was replaced by a UTM.
>>>>>> Because it does not.  And since the notation is mine, you don't
>>>>>> get to
>>>>>> say what it means.  You can ask questions, but that's about it.
>>>>>>
>>>>>>> When applied to this:
>>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>> When applied to those lines, the conditions become
>>>>>>      Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy  iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
>>>>>>      Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn  iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.
>>>>>> and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you
>>>>>
>>>>> Let's now go back to the original Ĥ applied to ⟨Ĥ⟩
>>>>>
>>>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>>>>
>>>>> Unless you assume that the embedded H at Ĥ.qx transitions to Ĥ.qn on
>>>>> the basis that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt there is no basis to
>>>>> determine whether or not Ĥ(⟨Ĥ⟩) halts.
>>>> I am not sure you really know what those lines (the formal ones) mean.
>>>> If you accept that
>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt
>>>> is indeed the case for any correctly constructed Ĥ, then the proof is
>>>> done and dusted.
>>>
>>> done and dusted seems like gibberish to me.
>>
>> It's a British idiom meaning "finished" or "all done".
>>
>>>> UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts if (and only if) Ĥ.q0 ⟨Ĥ⟩ transitions to Ĥ.qn
>>>> because
>>>> Ĥ.qn is the only final state in Ĥ.
>>>
>>> Yes.
>>>
>>>>> But Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn only if UTM(⟨Ĥ⟩
>>>>> ⟨Ĥ⟩) does /not/ halt.  No TM can behave as these lines specify.
>>
>> You missed this bit.
>>
>>> The only basis for the copy of H at Ĥ.qx to transition to Ĥ.qn would
>>> be that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>
>> Yes.  That's why there can't be any TM that behaves this way.  I'll try
>> once more to get you to see it...  If UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt, then
>> Ĥ.q0 ⟨Ĥ⟩ must transition to Ĥ.qn.  That's what the constraint means: X
>> occurs if, and only if, Y.  But if Ĥ behaves as it should, and Ĥ.q0 ⟨Ĥ⟩
>> does indeed transition to Ĥ.qn then, obviously, UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts.
>
> A Fallacy of equivocation error that neither you nor Linz ever noticed.
> It is the case that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) never halts ...
>
> When we know that an animal is a cat then it is definitely a cat even if
> it barks, wags its tail, and gives birth to puppies.

And what is being equivocated?

UTM(wM, w) MUST behave exactly like M(w).

H(wM, w), to be valid, ALWAYS answers in finite time, which is DIFFERENT
than UTM(wM, w), so they can NOT be the 'same'.

H gives an answer mapped by the results of UTM, it goes to Qn in finite
time if UTM will never halt.

If your H IS a UTM, we know how it fails, it doesn't answer.

If your H aborts its simulation, it isn't a UTM, and it treating itself
as one is an error.

It is CLEAR that if H -> Qnm, then so does H^, and HALTS.

It is the difference between what H does and what a UTM, which YOU make
an equivocation error on, that makes things different than what you claim.

FAIL.

>
>>
>> Then again, if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, a correctly behaving Ĥ must
>> transition to Ĥ.qy and then on to an endless loop.  But if that is what
>> Ĥ.q0 ⟨Ĥ⟩ does, then we know for sure that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>
>> I really don't think I can help any more than this unless you stop being
>> so sure of yourself and start to query what you know and what you think
>> these symbols really mean.  I am happy to help with that, but I don't
>> think you want that sort of help, do you?
>>
>
>

olcott <NoOne@NoWhere.com> writes:

> On 12/28/2021 6:22 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/27/2021 6:57 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 12/27/2021 8:50 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 12/26/2021 7:17 PM, Ben Bacarisse wrote:
>>>>>>
>>>>>>>> But for me, the main point is that if you use a comment symbol where a
>>>>>>>> mathematical constraint should be, please /don't/ say it's my
>>>>>>>> notation.
>>>>>> You appear to have stopped, at least for now.
>>>>>>
>>>>>>> I can't get Richard to understand that this:
>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>
>>>>>>> Means this:
>>>>>>> We are reporting on what the behavior of Ĥ applied to ⟨Ĥ⟩
>>>>>>> would be if the embedded H was replaced by a UTM.
>>>>>> Because it does not. And since the notation is mine, you don't get to
>>>>>> say what it means. You can ask questions, but that's about it.
>>>>>>
>>>>>>> When applied to this:
>>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
>>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>>>>>> When applied to those lines, the conditions become
>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) halts, and
>>>>>> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn iff UTM(⟨Ḧ⟩ ⟨Ḧ⟩) does not halt.
>>>>>> and since from those lines we can see that Ḧ(⟨Ḧ⟩) clearly halts, you
>>>>>
>>>>> Let's now go back to the original Ĥ applied to ⟨Ĥ⟩
>>>>>
>>>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>>>> Ĥq0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>>>>
>>>>> Unless you assume that the embedded H at Ĥ.qx transitions to Ĥ.qn on
>>>>> the basis that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt there is no basis to
>>>>> determine whether or not Ĥ(⟨Ĥ⟩) halts.
>>>> I am not sure you really know what those lines (the formal ones) mean.
>>>> If you accept that
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn iff UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt
>>>> is indeed the case for any correctly constructed Ĥ, then the proof is
>>>> done and dusted.
>>>
>>> done and dusted seems like gibberish to me.
>>
>> It's a British idiom meaning "finished" or "all done".
>>
>>>> UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts if (and only if) Ĥ.q0 ⟨Ĥ⟩ transitions to Ĥ.qn because
>>>> Ĥ.qn is the only final state in Ĥ.
>>>
>>> Yes.
>>>
>>>>> But Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn only if UTM(⟨Ĥ⟩
>>>>> ⟨Ĥ⟩) does /not/ halt. No TM can behave as these lines specify.
>>
>> You missed this bit.
>>
>>> The only basis for the copy of H at Ĥ.qx to transition to Ĥ.qn would
>>> be that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>>
>> Yes. That's why there can't be any TM that behaves this way. I'll try
>> once more to get you to see it... If UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt, then
>> Ĥ.q0 ⟨Ĥ⟩ must transition to Ĥ.qn. That's what the constraint means: X
>> occurs if, and only if, Y. But if Ĥ behaves as it should, and Ĥ.q0 ⟨Ĥ⟩
>> does indeed transition to Ĥ.qn then, obviously, UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts.
>
> A Fallacy of equivocation error that neither you nor Linz ever
> noticed.

No it's just a plain old contradiction that's been staring you in the
face for some time.

> It is the case that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) never halts ...
>
> When we know that an animal is a cat then it is definitely a cat even
> if it barks, wags its tail, and gives birth to puppies.

Not an analogous situation. A helpful analogy would be one where an
assumption leads, by logic alone, to a contradiction.

You have got through to the very end of the proof, but because you don't
like the result ("If God can not solve the Halting Problem, then there
is something wrong with the problem", PO 2012) you call the
contradiction "equivocation".

>> Then again, if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, a correctly behaving Ĥ must
>> transition to Ĥ.qy and then on to an endless loop. But if that is what
>> Ĥ.q0 ⟨Ĥ⟩ does, then we know for sure that UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does not halt.
>> I really don't think I can help any more than this unless you stop being
>> so sure of yourself and start to query what you know and what you think
>> these symbols really mean. I am happy to help with that, but I don't
>> think you want that sort of help, do you?

You don't want some help? Do you plan to just keep posting about
impossible TMs and identical TMs that don't behave identically? There
must be a better use of your time.

--
Ben.

This must be analyzed sequentially
This must be analyzed sequentially
This must be analyzed sequentially
This must be analyzed sequentially

Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

*My criterion measure with Ben's notational conventions*
H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt

We know that H would correctly decide the halt status of its input on
the basis of correctly deciding the halt status of the UTM simulation of
its input.

We know this because a UTM simulation of the Turing machine description
is computationally equivalent to the direct execution of this same
Turing machine.

We know that the copy of H is at Ĥ.qx (AKA embedded_H) applies this
same criterion measure to every instance of embedded_H to any recursive
depth.

We know that this means that embedded_H is examining the behavior of Ĥ
applied to ⟨Ĥ⟩ as if embedded_H was (hypothetically) replaced by a UTM.

We know that the behavior of this hypothetical machine is the criterion
measure for embedded_H.

We know that Ĥ applied to ⟨Ĥ⟩ would never stop running if embedded_H was
replaced by a UTM because Ĥ applied to ⟨Ĥ⟩ copies its input then UTM ⟨Ĥ⟩
⟨Ĥ⟩ would repeat this cycle ...

We know that this means that when embedded_H computes the mapping from
its input ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the UTM simulation of
this input that its transition to Ĥ.qn is correct.

https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (315-320)

On 2021-12-28 20:38, olcott wrote:
> This must be analyzed sequentially
> This must be analyzed sequentially
> This must be analyzed sequentially
> This must be analyzed sequentially
>
> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
> Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> *My criterion measure with Ben's notational conventions*
> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>
> We know that H would correctly decide the halt status of its input on
> the basis of correctly deciding the halt status of the UTM simulation of
> its input.
>
> We know this because a UTM simulation of the Turing machine description
> is computationally equivalent to the direct execution of this same
> Turing machine.
>
> We know that the copy of H is at  Ĥ.qx (AKA embedded_H) applies this
> same criterion measure to every instance of embedded_H to any recursive
> depth.
>
> We know that this means that embedded_H is examining the behavior of Ĥ
> applied to ⟨Ĥ⟩ as if embedded_H was (hypothetically) replaced by a UTM.

It doesn't mean that at all. It means that in principle you could
replace the *input* to embedded_H with wUTM wM w (though doing so would
be entirely pointless), but it most certainly does *not* mean that you
can replace embedded_H with a UTM (hypothetically or otherwise).

> We know that the behavior of this hypothetical machine is the criterion
> measure for embedded_H.

The criterion used by embedded_H is not the same thing as embedded_H.
You can't replace one with the other.

> We know that Ĥ applied to ⟨Ĥ⟩ would never stop running if embedded_H was
> replaced by a UTM because Ĥ applied to ⟨Ĥ⟩ copies its input then UTM ⟨Ĥ⟩
> ⟨Ĥ⟩ would repeat this cycle ...

Maybe we know this but it is utterly irrelevant since your replacement
of embedded_H with a UTM is entirely unjustified.

André

> We know that this means that when embedded_H computes the mapping from
> its input ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the UTM simulation of
> this input that its transition to Ĥ.qn is correct.
>
> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (315-320)
>

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 12/28/2021 9:54 PM, André G. Isaak wrote:
> On 2021-12-28 20:38, olcott wrote:
>> This must be analyzed sequentially
>> This must be analyzed sequentially
>> This must be analyzed sequentially
>> This must be analyzed sequentially
>>
>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
>> Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> *My criterion measure with Ben's notational conventions*
>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>
>> We know that H would correctly decide the halt status of its input on
>> the basis of correctly deciding the halt status of the UTM simulation
>> of its input.
>>
>> We know this because a UTM simulation of the Turing machine
>> description is computationally equivalent to the direct execution of
>> this same Turing machine.
>>
>> We know that the copy of H is at  Ĥ.qx (AKA embedded_H) applies this
>> same criterion measure to every instance of embedded_H to any
>> recursive depth.
>>
>> We know that this means that embedded_H is examining the behavior of Ĥ
>> applied to ⟨Ĥ⟩ as if embedded_H was (hypothetically) replaced by a UTM.
>
> It doesn't mean that at all. It means that in principle you could
> replace the *input* to embedded_H with wUTM wM w (though doing so would
> be entirely pointless), but it most certainly does *not* mean that you
> can replace embedded_H with a UTM (hypothetically or otherwise).
>
That is great I was hoping that you would come back. Now that you
analyzed this sequentially we can proceed frmo this point of analysis
forward.

When H bases its halt status decision on the UTM simulation of its input
then embedded_H also does this.

When embedded_H also does this then every embedded_H also does this.

When every embedded_H also does this then they all do this to every
recursive simulation depth.

This is the same as if embedded_H is basing its halt status decision on
whether or not any embedded_H must abort its input.

If any embedded_H must abort its input then we know it is because the
UTM simulation of the inputs to one of the instances of embedded_H does
not halt.

If the UTM simulation of the inputs to one of the instances of
embedded_H does not halt then this proves that the input to embedded_H
specifies infinitely nested simulation.

--
Copyright 2021 Pete Olcott

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

On 12/28/21 11:22 PM, olcott wrote:
> On 12/28/2021 9:54 PM, André G. Isaak wrote:
>> On 2021-12-28 20:38, olcott wrote:
>>> This must be analyzed sequentially
>>> This must be analyzed sequentially
>>> This must be analyzed sequentially
>>> This must be analyzed sequentially
>>>
>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>> Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> *My criterion measure with Ben's notational conventions*
>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>
>>> We know that H would correctly decide the halt status of its input on
>>> the basis of correctly deciding the halt status of the UTM simulation
>>> of its input.
>>>
>>> We know this because a UTM simulation of the Turing machine
>>> description is computationally equivalent to the direct execution of
>>> this same Turing machine.
>>>
>>> We know that the copy of H is at  Ĥ.qx (AKA embedded_H) applies this
>>> same criterion measure to every instance of embedded_H to any
>>> recursive depth.
>>>
>>> We know that this means that embedded_H is examining the behavior of
>>> Ĥ applied to ⟨Ĥ⟩ as if embedded_H was (hypothetically) replaced by a
>>> UTM.
>>
>> It doesn't mean that at all. It means that in principle you could
>> replace the *input* to embedded_H with wUTM wM w (though doing so
>> would be entirely pointless), but it most certainly does *not* mean
>> that you can replace embedded_H with a UTM (hypothetically or otherwise).
>>
> That is great I was hoping that you would come back. Now that you
> analyzed this sequentially we can proceed frmo this point of analysis
> forward.

That wasn't quite specified well.

You can put the inputs of H/embedded_H into a UTM to determine what the
correct answer would have been, but H can't do this as it requires the
ability to run a proof system to determine if the UTM is non-halting.

Not all truths are provable, so H can not do this. In fact, I think that
is the big part of your problem, you assume that all truth is provable,
but this problem shows that it is NOT, and you have to close your eyes
to the fact that this assumption makes your logical system inconsistent.

We can determine MANY non-halting systems to be non-halting, but there
are some system that H might decide as non-halting that we can not prove
its answer to be right or wrong.

In this case, since UTM(<H^>,<H^>) does Halt, we CAN prove that H
aborted incorrectly.

>
> When H bases its halt status decision on the UTM simulation of its input
> then embedded_H also does this.

Except that if THAT is actually what you are doing, then H can NOT
correctly answer for any non-halting input, because it takes unlimited time.

>
> When embedded_H also does this then every embedded_H also does this.
>
> When every embedded_H also does this then they all do this to every
> recursive simulation depth.

And NO H gets to answer. FAIL.

>
> This is the same as if embedded_H is basing its halt status decision on
> whether or not any embedded_H must abort its input.
>
> If any embedded_H must abort its input then we know it is because the
> UTM simulation of the inputs to one of the instances of embedded_H does
> not halt.

Nope, if ANY abort, then ALL abort, and ALL convert the computation that
called them from a potentially infinite into a finite computation.

Your logic is unsound.

>
> If the UTM simulation of the inputs to one of the instances of
> embedded_H does not halt then this proves that the input to embedded_H
> specifies infinitely nested simulation.
>

But ALL the systems must behave the same.

If you get two identical algorithms using identical data giving you
different answer, you have just shown that your logic system has gone
inconstant due to the introduction of some incorrrect 'fact'.

FAIL.

On 2021-12-28 21:22, olcott wrote:
> On 12/28/2021 9:54 PM, André G. Isaak wrote:
>> On 2021-12-28 20:38, olcott wrote:
>>> This must be analyzed sequentially
>>> This must be analyzed sequentially
>>> This must be analyzed sequentially
>>> This must be analyzed sequentially
>>>
>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>> Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> *My criterion measure with Ben's notational conventions*
>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>
>>> We know that H would correctly decide the halt status of its input on
>>> the basis of correctly deciding the halt status of the UTM simulation
>>> of its input.
>>>
>>> We know this because a UTM simulation of the Turing machine
>>> description is computationally equivalent to the direct execution of
>>> this same Turing machine.
>>>
>>> We know that the copy of H is at  Ĥ.qx (AKA embedded_H) applies this
>>> same criterion measure to every instance of embedded_H to any
>>> recursive depth.
>>>
>>> We know that this means that embedded_H is examining the behavior of
>>> Ĥ applied to ⟨Ĥ⟩ as if embedded_H was (hypothetically) replaced by a
>>> UTM.
>>
>> It doesn't mean that at all. It means that in principle you could
>> replace the *input* to embedded_H with wUTM wM w (though doing so
>> would be entirely pointless), but it most certainly does *not* mean
>> that you can replace embedded_H with a UTM (hypothetically or otherwise).
>>
> That is great I was hoping that you would come back. Now that you
> analyzed this sequentially we can proceed frmo this point of analysis
> forward.

How can we move forward from the point where I point out that you are
mistaken?

> When H bases its halt status decision on the UTM simulation of its input
> then embedded_H also does this.

Whether H bases its decision on Ĥ applied to ⟨Ĥ⟩ or on UTM ⟨Ĥ⟩ ⟨Ĥ⟩ makes
no difference.

Ĥ ⟨Ĥ⟩ halts.

UTM ⟨Ĥ⟩ ⟨Ĥ⟩ also halts.

So H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ must reach H.qy

> When embedded_H also does this then every embedded_H also does this.

Which means every embedded_H must also reach Ĥ.qy, but since this has
had an infinite loop appended you end up with a contradiction.

André

> When every embedded_H also does this then they all do this to every
> recursive simulation depth.
>
> This is the same as if embedded_H is basing its halt status decision on
> whether or not any embedded_H must abort its input.
>
> If any embedded_H must abort its input then we know it is because the
> UTM simulation of the inputs to one of the instances of embedded_H does
> not halt.
>
> If the UTM simulation of the inputs to one of the instances of
> embedded_H does not halt then this proves that the input to embedded_H
> specifies infinitely nested simulation.
>
>

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 12/29/2021 12:46 AM, André G. Isaak wrote:
> On 2021-12-28 21:22, olcott wrote:
>> On 12/28/2021 9:54 PM, André G. Isaak wrote:
>>> On 2021-12-28 20:38, olcott wrote:
>>>> This must be analyzed sequentially
>>>> This must be analyzed sequentially
>>>> This must be analyzed sequentially
>>>> This must be analyzed sequentially
>>>>
>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>> Ĥ.qn on the basis of the behavior of the UTM simulation of these
>>>> inputs.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> *My criterion measure with Ben's notational conventions*
>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>
>>>> We know that H would correctly decide the halt status of its input
>>>> on the basis of correctly deciding the halt status of the UTM
>>>> simulation of its input.
>>>>
>>>> We know this because a UTM simulation of the Turing machine
>>>> description is computationally equivalent to the direct execution of
>>>> this same Turing machine.
>>>>
>>>> We know that the copy of H is at  Ĥ.qx (AKA embedded_H) applies this
>>>> same criterion measure to every instance of embedded_H to any
>>>> recursive depth.
>>>>
>>>> We know that this means that embedded_H is examining the behavior of
>>>> Ĥ applied to ⟨Ĥ⟩ as if embedded_H was (hypothetically) replaced by a
>>>> UTM.
>>>
>>> It doesn't mean that at all. It means that in principle you could
>>> replace the *input* to embedded_H with wUTM wM w (though doing so
>>> would be entirely pointless), but it most certainly does *not* mean
>>> that you can replace embedded_H with a UTM (hypothetically or
>>> otherwise).
>>>
>> That is great I was hoping that you would come back. Now that you
>> analyzed this sequentially we can proceed frmo this point of analysis
>> forward.
>
> How can we move forward from the point where I point out that you are
> mistaken?
>
>> When H bases its halt status decision on the UTM simulation of its
>> input then embedded_H also does this.
>
> Whether H bases its decision on Ĥ applied to ⟨Ĥ⟩ or on UTM ⟨Ĥ⟩ ⟨Ĥ⟩ makes
> no difference.
>
> Ĥ ⟨Ĥ⟩ halts.
>

When we are trying to prove whether or not embedded_H answered yes or no
we cannot start with the assumption that it answers yes.

> UTM ⟨Ĥ⟩ ⟨Ĥ⟩ also halts.
>
> So H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ must reach H.qy
>

You are not applying UTM ⟨Ĥ⟩ ⟨Ĥ⟩ to every nested level of embedded_H
such that no embedded_H ever aborts the simulation of its input.

>> When embedded_H also does this then every embedded_H also does this.
>
> Which means every embedded_H must also reach Ĥ.qy, but since this has
> had an infinite loop appended you end up with a contradiction.
>
> André
>
>> When every embedded_H also does this then they all do this to every
>> recursive simulation depth.
>>
>> This is the same as if embedded_H is basing its halt status decision
>> on whether or not any embedded_H must abort its input.
>>
>> If any embedded_H must abort its input then we know it is because the
>> UTM simulation of the inputs to one of the instances of embedded_H
>> does not halt.
>>
>> If the UTM simulation of the inputs to one of the instances of
>> embedded_H does not halt then this proves that the input to embedded_H
>> specifies infinitely nested simulation.
>>
>>
>
>

--
Copyright 2021 Pete Olcott

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

On 12/29/21 10:01 AM, olcott wrote:
> On 12/29/2021 12:46 AM, André G. Isaak wrote:
>> On 2021-12-28 21:22, olcott wrote:
>>> On 12/28/2021 9:54 PM, André G. Isaak wrote:
>>>> On 2021-12-28 20:38, olcott wrote:
>>>>> This must be analyzed sequentially
>>>>> This must be analyzed sequentially
>>>>> This must be analyzed sequentially
>>>>> This must be analyzed sequentially
>>>>>
>>>>> Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> to Ĥ.qn on the basis of the behavior of the UTM simulation of these
>>>>> inputs.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> *My criterion measure with Ben's notational conventions*
>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>
>>>>> We know that H would correctly decide the halt status of its input
>>>>> on the basis of correctly deciding the halt status of the UTM
>>>>> simulation of its input.
>>>>>
>>>>> We know this because a UTM simulation of the Turing machine
>>>>> description is computationally equivalent to the direct execution
>>>>> of this same Turing machine.
>>>>>
>>>>> We know that the copy of H is at  Ĥ.qx (AKA embedded_H) applies
>>>>> this same criterion measure to every instance of embedded_H to any
>>>>> recursive depth.
>>>>>
>>>>> We know that this means that embedded_H is examining the behavior
>>>>> of Ĥ applied to ⟨Ĥ⟩ as if embedded_H was (hypothetically) replaced
>>>>> by a UTM.
>>>>
>>>> It doesn't mean that at all. It means that in principle you could
>>>> replace the *input* to embedded_H with wUTM wM w (though doing so
>>>> would be entirely pointless), but it most certainly does *not* mean
>>>> that you can replace embedded_H with a UTM (hypothetically or
>>>> otherwise).
>>>>
>>> That is great I was hoping that you would come back. Now that you
>>> analyzed this sequentially we can proceed frmo this point of analysis
>>> forward.
>>
>> How can we move forward from the point where I point out that you are
>> mistaken?
>>
>>> When H bases its halt status decision on the UTM simulation of its
>>> input then embedded_H also does this.
>>
>> Whether H bases its decision on Ĥ applied to ⟨Ĥ⟩ or on UTM ⟨Ĥ⟩ ⟨Ĥ⟩
>> makes no difference.
>>
>> Ĥ ⟨Ĥ⟩ halts.
>>
>
> When we are trying to prove whether or not embedded_H answered yes or no
> we cannot start with the assumption that it answers yes.

If H/embedded_H answers NO, it is wrong; if it answer YES, it is wrong.

FAIL.

H -> Qy if UTM(<H^>,<H^>) Halts, but if H does that <H^>(<H^>) doesn't
halt, so that was wrong.

H-> Qn if (UTM(<H^>,<H^>) Never halts, but it H does that <H^>(<H^)
Halts, so that was wrong.
>
>> UTM ⟨Ĥ⟩ ⟨Ĥ⟩ also halts.
>>
>> So H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ must reach H.qy
>>
>
> You are not applying UTM ⟨Ĥ⟩ ⟨Ĥ⟩ to every nested level of embedded_H
> such that no embedded_H ever aborts the simulation of its input.

The problem is that IF no embedded_H ever aborts the simulation of its
input, then H can't either, and then H doesn't answer, and so it isn't a
decider.

You can't assume "that no embedded_H ever abots the simulation of its
inputs" that isn't the critera that Halting is decider on. Halting is
decided on when embedded_H does what H does, as it must do the same
thing since it is the same algorithm with the same input.

FAIL.

>
>>> When embedded_H also does this then every embedded_H also does this.
>>
>> Which means every embedded_H must also reach Ĥ.qy, but since this has
>> had an infinite loop appended you end up with a contradiction.
>>
>> André
>>
>>> When every embedded_H also does this then they all do this to every
>>> recursive simulation depth.
>>>
>>> This is the same as if embedded_H is basing its halt status decision
>>> on whether or not any embedded_H must abort its input.
>>>
>>> If any embedded_H must abort its input then we know it is because the
>>> UTM simulation of the inputs to one of the instances of embedded_H
>>> does not halt.
>>>
>>> If the UTM simulation of the inputs to one of the instances of
>>> embedded_H does not halt then this proves that the input to
>>> embedded_H specifies infinitely nested simulation.
>>>
>>>
>>
>>
>
>