On Friday, January 14, 2022 at 7:49:26 PM UTC+1, olcott wrote:
> On 1/14/2022 12:11 PM, Alex C wrote:
> > On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
> >> On 1/14/2022 10:36 AM, Alex C wrote:
> >>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>>
> >>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must abort
> >>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop running.
> >>>>
> >>>> A simulating halt decider simulates N steps of its input until its input
> >>>> halts on its own or it correctly determines that a pure simulation of
> >>>> its input would never stop running.
> >>>>
> >>>> 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)
> >>>>
> >>>> --
> >>>> Copyright 2021 Pete Olcott
> >>>>
> >>>> Talent hits a target no one else can hit;
> >>>> Genius hits a target no one else can see.
> >>>> Arthur Schopenhauer
> >>>
> >>> A Turing machine applied to some input reaches one final state or one infinite loop, not two different ones. This is a consequence of the definition of determinism.
> >> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
> >> transitions to its final state of Ĥ.qn on the basis that a mathematical
> >> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the basis
> >> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
> >> simulating halt decider of embedded_H.
> >> --
> >> Copyright 2021 Pete Olcott
> >>
> >> Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see.
> >> Arthur Schopenhauer
> >
> > Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
> > is a question. A question that has only one answer. We can find the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM. Otherwise it is like saying:
> >
> > 2+2 = 4
> > 2+2 = 5
> That is not the question and you know it.
> I can't really understand your motivation to lie.
>
> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
> and the answer is: Ĥ.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

if that is the question then why did you post the nonsense about Ĥ.q0 ⟨Ĥ⟩

On 1/14/2022 5:53 PM, Alex C wrote:
> On Friday, January 14, 2022 at 7:49:26 PM UTC+1, olcott wrote:
>> On 1/14/2022 12:11 PM, Alex C wrote:
>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must abort
>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop running.
>>>>>>
>>>>>> A simulating halt decider simulates N steps of its input until its input
>>>>>> halts on its own or it correctly determines that a pure simulation of
>>>>>> its input would never stop running.
>>>>>>
>>>>>> 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)
>>>>>>
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> A Turing machine applied to some input reaches one final state or one infinite loop, not two different ones. This is a consequence of the definition of determinism.
>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>>> transitions to its final state of Ĥ.qn on the basis that a mathematical
>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the basis
>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
>>>> simulating halt decider of embedded_H.
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see.
>>>> Arthur Schopenhauer
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>> is a question. A question that has only one answer. We can find the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM. Otherwise it is like saying:
>>>
>>> 2+2 = 4
>>> 2+2 = 5
>> That is not the question and you know it.
>> I can't really understand your motivation to lie.
>>
>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>> and the answer is: Ĥ.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
>
> if that is the question then why did you post the nonsense about Ĥ.q0 ⟨Ĥ⟩

If you are user253751 then you already know the full background.
Otherwise you need to study the 6 pages of Linz text on this link:
https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf

This is a simplification of the Linz syntax at the bottom of page 319
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The copy of Linz H that is embedded at Ĥ.qx is called embedded_H.

--
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 1/14/2022 5:53 PM, Alex C wrote:
> On Friday, January 14, 2022 at 7:49:26 PM UTC+1, olcott wrote:
>> On 1/14/2022 12:11 PM, Alex C wrote:
>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must abort
>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop running.
>>>>>>
>>>>>> A simulating halt decider simulates N steps of its input until its input
>>>>>> halts on its own or it correctly determines that a pure simulation of
>>>>>> its input would never stop running.
>>>>>>
>>>>>> 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)
>>>>>>
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> A Turing machine applied to some input reaches one final state or one infinite loop, not two different ones. This is a consequence of the definition of determinism.
>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>>> transitions to its final state of Ĥ.qn on the basis that a mathematical
>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the basis
>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
>>>> simulating halt decider of embedded_H.
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see.
>>>> Arthur Schopenhauer
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>> is a question. A question that has only one answer. We can find the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM. Otherwise it is like saying:
>>>
>>> 2+2 = 4
>>> 2+2 = 5
>> That is not the question and you know it.
>> I can't really understand your motivation to lie.
>>
>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>> and the answer is: Ĥ.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
>
> if that is the question then why did you post the nonsense about Ĥ.q0 ⟨Ĥ⟩

If you are user253751 then you already know the full background.
Otherwise you need to study the 6 pages of Linz text on this link:
https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf

This is a simplification of the Linz syntax at the bottom of page 319
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The copy of Linz H that is embedded at Ĥ.qx is called embedded_H.

--
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 1/14/22 12:17 PM, olcott wrote:
> On 1/13/2022 2:33 PM, olcott wrote:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must
>> abort the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop
>> running.
>>
>> A simulating halt decider simulates N steps of its input until its
>> input halts on its own or it correctly determines that a pure
>> simulation of its input would never stop running.
>>
>> 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)
>>
>
> dbush said:
> @polcott There is a point of agreement, namely that you've successfully
> shown that a simulating H cannot simulate the P built from it to
> completion. Your confusion is that you think this is the same as
> not-halting. By definition, it is not.
>
> It must be a point of mutual agreement or it does not count as a point
> of agreement.
>
> I have successfully shown that sequences of configurations that never
> reach the final state of this sequence can be recognized as meeting the
> Linz definition of non-halting computations.
>
>

No, you have shown that the PARTIAL simulation by H never reaches the
final state of H^. That is NOT the definition of Halting.

You haven't proven that the UNCONDITIONAL simulation of H^ by a UTM
won't reach the terminal state, and in fact, it is proven that if H ->
H.Qn then H^ -> H^.Qn and Halts.

Thus, any H^ x for which H x x -> H.Qn is a Halting computation, which
includes the case of x being the description of H^, which is the problem
in question.

FAIL.

olcott <NoOne@NoWhere.com> writes:
[...]
> If you are user253751 then you already know the full background.
> Otherwise you need to study the 6 pages of Linz text on this link:
> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf

I see that you've posted a link to this PDF repeatedly. I hadn't
bothered to follow the link until now.

The PDF is a copy of chapter 12 of Peter Linz's book "An Introduction to
Formal Languages and Automata". The latest edition was published in
2016.

Is liarparadox.org your web site? If so, do you have permission from
the author or publisher to publish an entire chapter of Peter Linz's
book? In a few minutes of web searching, I've found no indication that
either Peter Linz or Jones & Bartlett Learning has made this book freely
available. (I seriously doubt that posting an entire chapter would
qualify as fair use.)

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

On 1/14/22 4:40 PM, olcott wrote:
> On 1/13/2022 2:33 PM, olcott wrote:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must
>> abort the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop
>> running.
>>
>> A simulating halt decider simulates N steps of its input until its
>> input halts on its own or it correctly determines that a pure
>> simulation of its input would never stop running.
>>
>> 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)
>>
>
> @polcott There is a point of agreement, namely that you've successfully
> shown that a simulating H cannot simulate the P built from it to
> completion. Your confusion is that you think this is the same as
> not-halting. By definition, it is not. – dbush
>
> Proof that my reviewers are not interested in an honest dialogue:
> (1) There are never any points of mutual agreement.
> (2) Whenever I prove my point reviewers always change the subject rather
> than acknowledge that I proved my point.

We agree that you have proven *A* point, just not the one you claim.

What you have proven is that NO H can PROVE that the H^ derived from it
is Halting, because there exists no H by your formula that can reach
that point.

This does NOT prove that any given instance of a H/H^ creates a
non-halting H^ machine.
>
> A simulating halt decider continues to simulate N steps of its input
> input until (a) The simulation ends on its own after reaching the final
> state specified by the input. (b) An infinite execution pattern has been
> recognized.

No, it hasn't as have been previously proven.

The decider you just described is proved to never halt and give a
decision and thus is wrong.

FAIL.

>
> It is ridiculously stupid to claim that the simulating halt decider
> fails on the basis that it cannot simulate an input that specifies
> infinite execution to completion.

WHY? The problem is that you haven't actually defined what your H is,
but just assume that you can do the impossible job.

Once you give H any pattern that it sees in its simulation of H^, then
the H^ you build from THAT H can be shown to Halt, and thus the pattern
was incorrect.

It isn't that strange an idea that you can build a Turing Machine that
uses a copy of the decider (that needs to exist first) to make that
decider wrong.

H ends up stuck between having to make a decision, and a machine that
knows what decision it will make and act the opposite.

Try playing Rock-Paper-Scissor with someone where you have to put out
your move first, then they get to act. This is the place that H is in,
since H has to exist first. H^ just declares its template, it will
choose what ever answer will make H wrong.

>
> H cannot simulate P to completion because P has no completion. All the
> HP counter-example instance specify infinitely nested simulation to
> every simulating halt decider.
>

WRONG. The problem is there is no H in the first place to simulate P,
and thus there is no P to simulate.

Once you actually create a specific H, then we can see that the H^/P
created from it will be able to foil that H.

You arguement fails to actually create an H with an actual defined
algorithm to run.

On 1/14/22 5:08 PM, olcott wrote:
> On 1/14/2022 3:40 PM, olcott wrote:
>> On 1/13/2022 2:33 PM, olcott wrote:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must
>>> abort the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never
>>> stop running.
>>>
>>> A simulating halt decider simulates N steps of its input until its
>>> input halts on its own or it correctly determines that a pure
>>> simulation of its input would never stop running.
>>>
>>> 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)
>>>
>>
>> @polcott There is a point of agreement, namely that you've
>> successfully shown that a simulating H cannot simulate the P built
>> from it to completion. Your confusion is that you think this is the
>> same as not-halting. By definition, it is not. – dbush
>>
>> Proof that my reviewers are not interested in an honest dialogue:
>> (1) There are never any points of mutual agreement.
>> (2) Whenever I prove my point reviewers always change the subject
>> rather than acknowledge that I proved my point.
>>
>> A simulating halt decider continues to simulate N steps of its input
>> input until (a) The simulation ends on its own after reaching the
>> final state specified by the input. (b) An infinite execution pattern
>> has been recognized.
>>
>> It is ridiculously stupid to claim that the simulating halt decider
>> fails on the basis that it cannot simulate an input that specifies
>> infinite execution to completion.
>>
>> H cannot simulate P to completion because P has no completion. All the
>> HP counter-example instance specify infinitely nested simulation to
>> every simulating halt decider.
>>
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> Because no finite number of N steps of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
> embedded_H ever reach a final state of Ĥ, embedded_H correctly
> determines that its input meets the Linz definition of a computation
> that does not halt. At this point embedded_H aborts the simulation of
> its input and correctly transitions to Ĥ.qn.
>

But since a given H will only simulate H^ for N steps, then the fact
that H didn't see the final state of H^ in that N steps doesn't say that
it can't reach it in some larger value K.

The DEFINITION of Halting is that it will eventually get there is SOME
finite number (not a specific finite number), and if it does in a K
greater than N doesn't mean that it didn't. And if you change your H to
run longer to try to catch that K, you changed H and thus H^ and the new
H^ will have a larger K.

The fact that H^ depends on H means that it can easily be the case that
for a given H/H^ pair, the K steps that H^ stops in is ALWAYS greater
than the N that H simulated for, so all you have shown is that there is
no N such that N > K(N) not that for any particular N there does not
exist a finite K.

You have failed to prove anything at all like what you need to prove.

On 1/14/22 11:58 AM, olcott wrote:
> On 1/14/2022 10:36 AM, Alex C wrote:
>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must abort
>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop
>>> running.
>>>
>>> A simulating halt decider simulates N steps of its input until its input
>>> halts on its own or it correctly determines that a pure simulation of
>>> its input would never stop running.
>>>
>>> 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)
>>>
>>> --
>>> Copyright 2021 Pete Olcott
>>>
>>> Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see.
>>> Arthur Schopenhauer
>>
>> A Turing machine applied to some input reaches one final state or one
>> infinite loop, not two different ones. This is a consequence of the
>> definition of determinism.
>
> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
> transitions to its final state of Ĥ.qn on the basis that a mathematical
> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the basis
> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
> simulating halt decider of embedded_H.
>

H may compute a mapping of H^ applied to <H^> mapping to H.Qn, but that
is NOT the Halting Function, since we KNOW that if H x x -> H.Qn that we
also have that H^ x -> H^.Qn and HALTS, so H^ applied to <H^> goes to
H^.Qn (since you have claimed that H <H^> <H^> goes to H.Qn) and thus Halts.

Thus H does NOT compute the Halting Function, but something else.

All you have proved is that for Hn^ based on Hn that doesn't abort its
simulation that Hn^ <Hn^> doesn't halt, but it is only Ha that gives
that answer, and we don't care if Ha <Hn^> <Hn^> gets the right answer,
you need Ha to get the right answer for Ha <Ha^> <Ha^> which it doesn't
as we just showed that Ha^ <Ha^> halts, becuase Ha went to Ha.Qn

FAIL

On 1/14/22 1:49 PM, olcott wrote:
> On 1/14/2022 12:11 PM, Alex C wrote:
>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must
>>>>> abort
>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop
>>>>> running.
>>>>>
>>>>> A simulating halt decider simulates N steps of its input until its
>>>>> input
>>>>> halts on its own or it correctly determines that a pure simulation of
>>>>> its input would never stop running.
>>>>>
>>>>> 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)
>>>>>
>>>>> --
>>>>> Copyright 2021 Pete Olcott
>>>>>
>>>>> Talent hits a target no one else can hit;
>>>>> Genius hits a target no one else can see.
>>>>> Arthur Schopenhauer
>>>>
>>>> A Turing machine applied to some input reaches one final state or
>>>> one infinite loop, not two different ones. This is a consequence of
>>>> the definition of determinism.
>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>> transitions to its final state of Ĥ.qn on the basis that a mathematical
>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the basis
>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
>>> simulating halt decider of embedded_H.
>>> --
>>> Copyright 2021 Pete Olcott
>>>
>>> Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see.
>>> Arthur Schopenhauer
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>> is a question. A question that has only one answer. We can find the
>> answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM. Otherwise it
>> is like saying:
>>
>> 2+2 = 4
>> 2+2 = 5
>
> That is not the question and you know it.
> I can't really understand your motivation to lie.
>
> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
> and the answer is: Ĥ.qn.
>

Except it isn't

The DEFINITION of a correct H was

H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)

But we have that H^ y will go to H^.Qn and Halt if H y y -> H.Qn

Since this is just the case where y = <H^> we have that

H <H^> <H^> should go to H.Qn only if H^ <H^> will not halt, but we just
showed that if H <H^> <H^> goes to H.Qn then H^ <H^> will also go to
H^.Qn and Halt, so H didn't meet its requirements.

FAIL.

On 1/14/22 2:46 PM, olcott wrote:
> On 1/14/2022 12:49 PM, olcott wrote:
>> On 1/14/2022 12:11 PM, Alex C wrote:
>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must
>>>>>> abort
>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop
>>>>>> running.
>>>>>>
>>>>>> A simulating halt decider simulates N steps of its input until its
>>>>>> input
>>>>>> halts on its own or it correctly determines that a pure simulation of
>>>>>> its input would never stop running.
>>>>>>
>>>>>> 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)
>>>>>>
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> A Turing machine applied to some input reaches one final state or
>>>>> one infinite loop, not two different ones. This is a consequence of
>>>>> the definition of determinism.
>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>>> transitions to its final state of Ĥ.qn on the basis that a mathematical
>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the basis
>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
>>>> simulating halt decider of embedded_H.
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see.
>>>> Arthur Schopenhauer
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>> is a question. A question that has only one answer. We can find the
>>> answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM. Otherwise it
>>> is like saying:
>>>
>>> 2+2 = 4
>>> 2+2 = 5
>>
>> That is not the question and you know it.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> There can only be a conditional branch at the point in the execution
> trace where there is conditional code. The point in the execution trace
> that you pointed to was an unconditional branch.
>

??? The ⊢* better have a condition branch in it as it goes to two
different later states based on some condition.

It THAT you problem?

>> I can't really understand your motivation to lie.
>>
>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>> and the answer is: Ĥ.qn.
>>
>>
>>
>
>

On 1/14/2022 8:08 PM, Keith Thompson wrote:
> olcott <NoOne@NoWhere.com> writes:
> [...]
>> If you are user253751 then you already know the full background.
>> Otherwise you need to study the 6 pages of Linz text on this link:
>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>
> I see that you've posted a link to this PDF repeatedly. I hadn't
> bothered to follow the link until now.
>
> The PDF is a copy of chapter 12 of Peter Linz's book "An Introduction to
> Formal Languages and Automata". The latest edition was published in
> 2016.
>
> Is liarparadox.org your web site? If so, do you have permission from
> the author or publisher to publish an entire chapter of Peter Linz's
> book? In a few minutes of web searching, I've found no indication that
> either Peter Linz or Jones & Bartlett Learning has made this book freely
> available. (I seriously doubt that posting an entire chapter would
> qualify as fair use.)
>

Chapter 12 is 28 pages long.
Since I am refuting his proof this justifies fair use.
The first 2.5 pages specifies the terminology that applies to
the proof.

--
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 1/14/2022 8:28 PM, Richard Damon wrote:
>
> On 1/14/22 1:49 PM, olcott wrote:
>> On 1/14/2022 12:11 PM, Alex C wrote:
>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx must
>>>>>> abort
>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop
>>>>>> running.
>>>>>>
>>>>>> A simulating halt decider simulates N steps of its input until its
>>>>>> input
>>>>>> halts on its own or it correctly determines that a pure simulation of
>>>>>> its input would never stop running.
>>>>>>
>>>>>> 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)
>>>>>>
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> A Turing machine applied to some input reaches one final state or
>>>>> one infinite loop, not two different ones. This is a consequence of
>>>>> the definition of determinism.
>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>>> transitions to its final state of Ĥ.qn on the basis that a mathematical
>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the basis
>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
>>>> simulating halt decider of embedded_H.
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see.
>>>> Arthur Schopenhauer
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>> is a question. A question that has only one answer. We can find the
>>> answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM. Otherwise it
>>> is like saying:
>>>
>>> 2+2 = 4
>>> 2+2 = 5
>>
>> That is not the question and you know it.
>> I can't really understand your motivation to lie.
>>
>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>> and the answer is: Ĥ.qn.
>>
>
> Except it isn't
>
> The DEFINITION of a correct H was
>
> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>

The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.

Do you understand that this is correct, or do you not know computer
science well enough to understand that this is correct?

> But we have that H^ y will go to H^.Qn and Halt if H y y -> H.Qn
>
> Since this is just the case where y = <H^> we have that
>
> H <H^> <H^> should go to H.Qn only if H^ <H^> will not halt, but we just
> showed that if H <H^> <H^> goes to H.Qn then H^ <H^> will also go to
> H^.Qn and Halt, so H didn't meet its requirements.
>
> FAIL.

--
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 1/14/22 10:21 PM, olcott wrote:
> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>
>> On 1/14/22 1:49 PM, olcott wrote:
>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx
>>>>>>> must abort
>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop
>>>>>>> running.
>>>>>>>
>>>>>>> A simulating halt decider simulates N steps of its input until
>>>>>>> its input
>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>> simulation of
>>>>>>> its input would never stop running.
>>>>>>>
>>>>>>> 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)
>>>>>>>
>>>>>>> --
>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>
>>>>>>> Talent hits a target no one else can hit;
>>>>>>> Genius hits a target no one else can see.
>>>>>>> Arthur Schopenhauer
>>>>>>
>>>>>> A Turing machine applied to some input reaches one final state or
>>>>>> one infinite loop, not two different ones. This is a consequence
>>>>>> of the definition of determinism.
>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>> mathematical
>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the basis
>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
>>>>> simulating halt decider of embedded_H.
>>>>> --
>>>>> Copyright 2021 Pete Olcott
>>>>>
>>>>> Talent hits a target no one else can hit;
>>>>> Genius hits a target no one else can see.
>>>>> Arthur Schopenhauer
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>> is a question. A question that has only one answer. We can find the
>>>> answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM. Otherwise
>>>> it is like saying:
>>>>
>>>> 2+2 = 4
>>>> 2+2 = 5
>>>
>>> That is not the question and you know it.
>>> I can't really understand your motivation to lie.
>>>
>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>> and the answer is: Ĥ.qn.
>>>
>>
>> Except it isn't
>>
>> The DEFINITION of a correct H was
>>
>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>
>
> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
> based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> Do you understand that this is correct, or do you not know computer
> science well enough to understand that this is correct?

Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^ applied
to <H^> (BY DEFINITION) which goes to H^.Qn and Halts if the copy of H
in it goes to H.Qn, which it does if H mapped <H^> <H^> to H.Qn which
you claim, so the behavior specified by the input is HALTING.

THUS if H maps <H^> <H^> to H.Qn, then by its definition it SHOULD have
mapped it to H.Qy, so it was WRONG.

>
>> But we have that H^ y will go to H^.Qn and Halt if H y y -> H.Qn
>>
>> Since this is just the case where y = <H^> we have that
>>
>> H <H^> <H^> should go to H.Qn only if H^ <H^> will not halt, but we
>> just showed that if H <H^> <H^> goes to H.Qn then H^ <H^> will also go
>> to H^.Qn and Halt, so H didn't meet its requirements.
>>
>> FAIL.
>
>

On 1/14/2022 9:31 PM, Richard Damon wrote:
> On 1/14/22 10:21 PM, olcott wrote:
>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>
>>> On 1/14/22 1:49 PM, olcott wrote:
>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx
>>>>>>>> must abort
>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never stop
>>>>>>>> running.
>>>>>>>>
>>>>>>>> A simulating halt decider simulates N steps of its input until
>>>>>>>> its input
>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>> simulation of
>>>>>>>> its input would never stop running.
>>>>>>>>
>>>>>>>> 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)
>>>>>>>>
>>>>>>>> --
>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>
>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>> Genius hits a target no one else can see.
>>>>>>>> Arthur Schopenhauer
>>>>>>>
>>>>>>> A Turing machine applied to some input reaches one final state or
>>>>>>> one infinite loop, not two different ones. This is a consequence
>>>>>>> of the definition of determinism.
>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>> mathematical
>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the basis
>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
>>>>>> simulating halt decider of embedded_H.
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>> is a question. A question that has only one answer. We can find the
>>>>> answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM. Otherwise
>>>>> it is like saying:
>>>>>
>>>>> 2+2 = 4
>>>>> 2+2 = 5
>>>>
>>>> That is not the question and you know it.
>>>> I can't really understand your motivation to lie.
>>>>
>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>> and the answer is: Ĥ.qn.
>>>>
>>>
>>> Except it isn't
>>>
>>> The DEFINITION of a correct H was
>>>
>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>
>>
>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> Do you understand that this is correct, or do you not know computer
>> science well enough to understand that this is correct?
>
> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^ applied
> to <H^> (BY DEFINITION) which goes to H^.Qn and Halts if the copy of H
> in it goes to H.Qn, which it does if H mapped <H^> <H^> to H.Qn which
> you claim, so the behavior specified by the input is HALTING.
>

I won't count that as wrong because the part that you got wrong was
outside the scope of the original question.

You 100% agree with this:
The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.

The next step after we agree on that point is:
How we measure the actual behavior of the input to embedded_H: ⟨Ĥ⟩ ⟨Ĥ⟩ ?

> THUS if H maps <H^> <H^> to H.Qn, then by its definition it SHOULD have
> mapped it to H.Qy, so it was WRONG.
>
>>
>>> But we have that H^ y will go to H^.Qn and Halt if H y y -> H.Qn
>>>
>>> Since this is just the case where y = <H^> we have that
>>>
>>> H <H^> <H^> should go to H.Qn only if H^ <H^> will not halt, but we
>>> just showed that if H <H^> <H^> goes to H.Qn then H^ <H^> will also
>>> go to H^.Qn and Halt, so H didn't meet its requirements.
>>>
>>> FAIL.
>>
>>
>

--
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 1/14/22 10:44 PM, olcott wrote:
> On 1/14/2022 9:31 PM, Richard Damon wrote:
>> On 1/14/22 10:21 PM, olcott wrote:
>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>
>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx
>>>>>>>>> must abort
>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never
>>>>>>>>> stop running.
>>>>>>>>>
>>>>>>>>> A simulating halt decider simulates N steps of its input until
>>>>>>>>> its input
>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>> simulation of
>>>>>>>>> its input would never stop running.
>>>>>>>>>
>>>>>>>>> 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)
>>>>>>>>>
>>>>>>>>> --
>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>
>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>> Arthur Schopenhauer
>>>>>>>>
>>>>>>>> A Turing machine applied to some input reaches one final state
>>>>>>>> or one infinite loop, not two different ones. This is a
>>>>>>>> consequence of the definition of determinism.
>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>>> mathematical
>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the
>>>>>>> basis
>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to the
>>>>>>> simulating halt decider of embedded_H.
>>>>>>> --
>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>
>>>>>>> Talent hits a target no one else can hit;
>>>>>>> Genius hits a target no one else can see.
>>>>>>> Arthur Schopenhauer
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>> is a question. A question that has only one answer. We can find
>>>>>> the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM.
>>>>>> Otherwise it is like saying:
>>>>>>
>>>>>> 2+2 = 4
>>>>>> 2+2 = 5
>>>>>
>>>>> That is not the question and you know it.
>>>>> I can't really understand your motivation to lie.
>>>>>
>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>> and the answer is: Ĥ.qn.
>>>>>
>>>>
>>>> Except it isn't
>>>>
>>>> The DEFINITION of a correct H was
>>>>
>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>
>>>
>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> Do you understand that this is correct, or do you not know computer
>>> science well enough to understand that this is correct?
>>
>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^ applied
>> to <H^> (BY DEFINITION) which goes to H^.Qn and Halts if the copy of H
>> in it goes to H.Qn, which it does if H mapped <H^> <H^> to H.Qn which
>> you claim, so the behavior specified by the input is HALTING.
>>
>
> I won't count that as wrong because the part that you got wrong was
> outside the scope of the original question.
>
> You 100% agree with this:
> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> The next step after we agree on that point is:
> How we measure the actual behavior of the input to embedded_H: ⟨Ĥ⟩ ⟨Ĥ⟩ ?

From the definition of the problem: it is defined as the behavior of H^
applied to <H^> or its equivalent of UTM(<H^>,<H^>) and nothing else.

Remember H <X> y -> H.Qy IFF X y Halts, and -> H.Qn IFF X y never Halts.

THAT IS THE DEFINITION.

By the definition of a UTM, this is the equivalent to:

H x y -> H.Qy IFF UTM(x,y) Halts and -> H.Qn IFF UTM(x,y) never Halts.

Note, by the construction of H^, if H x x -> H.Qn then H^ x -> H^.Qn and
Halts.

Thus IFF H <H^> <H^> gives your claimed correct answer of H.Qn then by
the construction of H^ we have that H^ <H^> will also go to H^.Qn and Halt.

Thus H <H^> <H^> -> H.Qn is incorrect, as we just showed that its input
will Halt if H behaves as you just claimed.

So either H gave the answer Qn and was wrong, or the answer was Qn but H
didn't give it. Either way H is wrong.

FAIL.

>
>
>> THUS if H maps <H^> <H^> to H.Qn, then by its definition it SHOULD
>> have mapped it to H.Qy, so it was WRONG.
>>
>>>
>>>> But we have that H^ y will go to H^.Qn and Halt if H y y -> H.Qn
>>>>
>>>> Since this is just the case where y = <H^> we have that
>>>>
>>>> H <H^> <H^> should go to H.Qn only if H^ <H^> will not halt, but we
>>>> just showed that if H <H^> <H^> goes to H.Qn then H^ <H^> will also
>>>> go to H^.Qn and Halt, so H didn't meet its requirements.
>>>>
>>>> FAIL.
>>>
>>>
>>
>
>

On 1/14/2022 10:16 PM, Richard Damon wrote:
> On 1/14/22 10:44 PM, olcott wrote:
>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>> On 1/14/22 10:21 PM, olcott wrote:
>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx
>>>>>>>>>> must abort
>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never
>>>>>>>>>> stop running.
>>>>>>>>>>
>>>>>>>>>> A simulating halt decider simulates N steps of its input until
>>>>>>>>>> its input
>>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>>> simulation of
>>>>>>>>>> its input would never stop running.
>>>>>>>>>>
>>>>>>>>>> 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)
>>>>>>>>>>
>>>>>>>>>> --
>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>
>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>
>>>>>>>>> A Turing machine applied to some input reaches one final state
>>>>>>>>> or one infinite loop, not two different ones. This is a
>>>>>>>>> consequence of the definition of determinism.
>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>>>> mathematical
>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the
>>>>>>>> basis
>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation to
>>>>>>>> the
>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>> --
>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>
>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>> Genius hits a target no one else can see.
>>>>>>>> Arthur Schopenhauer
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>> is a question. A question that has only one answer. We can find
>>>>>>> the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM.
>>>>>>> Otherwise it is like saying:
>>>>>>>
>>>>>>> 2+2 = 4
>>>>>>> 2+2 = 5
>>>>>>
>>>>>> That is not the question and you know it.
>>>>>> I can't really understand your motivation to lie.
>>>>>>
>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>> and the answer is: Ĥ.qn.
>>>>>>
>>>>>
>>>>> Except it isn't
>>>>>
>>>>> The DEFINITION of a correct H was
>>>>>
>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>
>>>>
>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> Do you understand that this is correct, or do you not know computer
>>>> science well enough to understand that this is correct?
>>>
>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^
>>> applied to <H^> (BY DEFINITION) which goes to H^.Qn and Halts if the
>>> copy of H in it goes to H.Qn, which it does if H mapped <H^> <H^> to
>>> H.Qn which you claim, so the behavior specified by the input is HALTING.
>>>
>>
>> I won't count that as wrong because the part that you got wrong was
>> outside the scope of the original question.
>>
>> You 100% agree with this:
>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> The next step after we agree on that point is:
>> How we measure the actual behavior of the input to embedded_H: ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>
> From the definition of the problem: it is defined as the behavior of H^
> applied to <H^> or its equivalent of UTM(<H^>,<H^>) and nothing else.
Ah so you don't understand enough computer science to know that every
decider implements a computable function that maps its input(s) to an
accept reject state.

Unless you understand this we cannot proceed. It makes sense that I
apply this same threshold of understanding to all of my reviewers.

--
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 1/14/22 11:26 PM, olcott wrote:
> On 1/14/2022 10:16 PM, Richard Damon wrote:
>> On 1/14/22 10:44 PM, olcott wrote:
>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> It is the case that the copy of H (called embedded_H) at Ĥ.qx
>>>>>>>>>>> must abort
>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never
>>>>>>>>>>> stop running.
>>>>>>>>>>>
>>>>>>>>>>> A simulating halt decider simulates N steps of its input
>>>>>>>>>>> until its input
>>>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>>>> simulation of
>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>
>>>>>>>>>>> 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)
>>>>>>>>>>>
>>>>>>>>>>> --
>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>
>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>
>>>>>>>>>> A Turing machine applied to some input reaches one final state
>>>>>>>>>> or one infinite loop, not two different ones. This is a
>>>>>>>>>> consequence of the definition of determinism.
>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx correctly
>>>>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>>>>> mathematical
>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on the
>>>>>>>>> basis
>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation
>>>>>>>>> to the
>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>> --
>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>
>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>> Arthur Schopenhauer
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>> is a question. A question that has only one answer. We can find
>>>>>>>> the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM.
>>>>>>>> Otherwise it is like saying:
>>>>>>>>
>>>>>>>> 2+2 = 4
>>>>>>>> 2+2 = 5
>>>>>>>
>>>>>>> That is not the question and you know it.
>>>>>>> I can't really understand your motivation to lie.
>>>>>>>
>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>
>>>>>>
>>>>>> Except it isn't
>>>>>>
>>>>>> The DEFINITION of a correct H was
>>>>>>
>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>>
>>>>>
>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> Do you understand that this is correct, or do you not know computer
>>>>> science well enough to understand that this is correct?
>>>>
>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^
>>>> applied to <H^> (BY DEFINITION) which goes to H^.Qn and Halts if the
>>>> copy of H in it goes to H.Qn, which it does if H mapped <H^> <H^> to
>>>> H.Qn which you claim, so the behavior specified by the input is
>>>> HALTING.
>>>>
>>>
>>> I won't count that as wrong because the part that you got wrong was
>>> outside the scope of the original question.
>>>
>>> You 100% agree with this:
>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> The next step after we agree on that point is:
>>> How we measure the actual behavior of the input to embedded_H: ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>>
>>  From the definition of the problem: it is defined as the behavior of
>> H^ applied to <H^> or its equivalent of UTM(<H^>,<H^>) and nothing else.
> Ah so you don't understand enough computer science to know that every
> decider implements a computable function that maps its input(s) to an
> accept reject state.
>
> Unless you understand this we cannot proceed. It makes sense that I
> apply this same threshold of understanding to all of my reviewers.
>

No, I understand that perfectly, H needs to compute a mapping from its
inputs, but the definition of the mapping, in this case is the Halting
Function, which it turns out is NOT directly computatable from the inputs.

THAT IS THE WHOLE ISSUE.

If you are saying that it is impossible for H to compute the mapping
based on this definition, then you are just agreeing with Linz and
Turing and everyone else that the Halting Function is NOT computable.

So, what is the issue?

Either you are agreeing that the Halting Function is not computable, or
you are going to show everyone up by showing how you can actually
compute this function as it is defined, which means you don't get to
change the definition based on the fact that it isn't computable.

I think the issue really is that you don't really understand the
question you are trying to disprove the answer to.

On 1/14/2022 10:34 PM, Richard Damon wrote:
> On 1/14/22 11:26 PM, olcott wrote:
>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>> On 1/14/22 10:44 PM, olcott wrote:
>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott wrote:
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> It is the case that the copy of H (called embedded_H) at
>>>>>>>>>>>> Ĥ.qx must abort
>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never
>>>>>>>>>>>> stop running.
>>>>>>>>>>>>
>>>>>>>>>>>> A simulating halt decider simulates N steps of its input
>>>>>>>>>>>> until its input
>>>>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>>>>> simulation of
>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>
>>>>>>>>>>>> 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)
>>>>>>>>>>>>
>>>>>>>>>>>> --
>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>
>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>
>>>>>>>>>>> A Turing machine applied to some input reaches one final
>>>>>>>>>>> state or one infinite loop, not two different ones. This is a
>>>>>>>>>>> consequence of the definition of determinism.
>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx
>>>>>>>>>> correctly
>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>>>>>> mathematical
>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on
>>>>>>>>>> the basis
>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation
>>>>>>>>>> to the
>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>> --
>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>
>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>> is a question. A question that has only one answer. We can find
>>>>>>>>> the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a UTM.
>>>>>>>>> Otherwise it is like saying:
>>>>>>>>>
>>>>>>>>> 2+2 = 4
>>>>>>>>> 2+2 = 5
>>>>>>>>
>>>>>>>> That is not the question and you know it.
>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>
>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>
>>>>>>>
>>>>>>> Except it isn't
>>>>>>>
>>>>>>> The DEFINITION of a correct H was
>>>>>>>
>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>>>
>>>>>>
>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy
>>>>>> or Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>> Do you understand that this is correct, or do you not know
>>>>>> computer science well enough to understand that this is correct?
>>>>>
>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^
>>>>> applied to <H^> (BY DEFINITION) which goes to H^.Qn and Halts if
>>>>> the copy of H in it goes to H.Qn, which it does if H mapped <H^>
>>>>> <H^> to H.Qn which you claim, so the behavior specified by the
>>>>> input is HALTING.
>>>>>
>>>>
>>>> I won't count that as wrong because the part that you got wrong was
>>>> outside the scope of the original question.
>>>>
>>>> You 100% agree with this:
>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> The next step after we agree on that point is:
>>>> How we measure the actual behavior of the input to embedded_H: ⟨Ĥ⟩
>>>> ⟨Ĥ⟩ ?
>>>
>>>  From the definition of the problem: it is defined as the behavior of
>>> H^ applied to <H^> or its equivalent of UTM(<H^>,<H^>) and nothing else.
>> Ah so you don't understand enough computer science to know that every
>> decider implements a computable function that maps its input(s) to an
>> accept reject state.
>>
>> Unless you understand this we cannot proceed. It makes sense that I
>> apply this same threshold of understanding to all of my reviewers.
>>
>
> No, I understand that perfectly, H needs to compute a mapping from its
> inputs, but the definition of the mapping, in this case is the Halting
> Function, which it turns out is NOT directly computatable from the inputs.
>

Because you tend to weasel word all over the place and have your
rebuttal ignore what I am currently saying and instead refer to
something that I said 50 posts ago let's be perfectly clear:

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

The copy of H at Ĥ.qx referred to as embedded_H must compute the
mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn

> THAT IS THE WHOLE ISSUE.
>
> If you are saying that it is impossible for H to compute the mapping
> based on this definition, then you are just agreeing with Linz and
> Turing and everyone else that the Halting Function is NOT computable.
>
> So, what is the issue?
>
> Either you are agreeing that the Halting Function is not computable, or
> you are going to show everyone up by showing how you can actually
> compute this function as it is defined, which means you don't get to
> change the definition based on the fact that it isn't computable.
>
> I think the issue really is that you don't really understand the
> question you are trying to disprove the answer to.

--
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 1/14/22 11:51 PM, olcott wrote:
> On 1/14/2022 10:34 PM, Richard Damon wrote:
>> On 1/14/22 11:26 PM, olcott wrote:
>>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>>> On 1/14/22 10:44 PM, olcott wrote:
>>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is the case that the copy of H (called embedded_H) at
>>>>>>>>>>>>> Ĥ.qx must abort
>>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would never
>>>>>>>>>>>>> stop running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A simulating halt decider simulates N steps of its input
>>>>>>>>>>>>> until its input
>>>>>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>
>>>>>>>>>>>>> --
>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>
>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>
>>>>>>>>>>>> A Turing machine applied to some input reaches one final
>>>>>>>>>>>> state or one infinite loop, not two different ones. This is
>>>>>>>>>>>> a consequence of the definition of determinism.
>>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx
>>>>>>>>>>> correctly
>>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>>>>>>> mathematical
>>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on
>>>>>>>>>>> the basis
>>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested simulation
>>>>>>>>>>> to the
>>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>>> --
>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>
>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>>> is a question. A question that has only one answer. We can
>>>>>>>>>> find the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a
>>>>>>>>>> UTM. Otherwise it is like saying:
>>>>>>>>>>
>>>>>>>>>> 2+2 = 4
>>>>>>>>>> 2+2 = 5
>>>>>>>>>
>>>>>>>>> That is not the question and you know it.
>>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>>
>>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Except it isn't
>>>>>>>>
>>>>>>>> The DEFINITION of a correct H was
>>>>>>>>
>>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>>>>
>>>>>>>
>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy
>>>>>>> or Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩
>>>>>>> ⟨Ĥ⟩.
>>>>>>>
>>>>>>> Do you understand that this is correct, or do you not know
>>>>>>> computer science well enough to understand that this is correct?
>>>>>>
>>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^
>>>>>> applied to <H^> (BY DEFINITION) which goes to H^.Qn and Halts if
>>>>>> the copy of H in it goes to H.Qn, which it does if H mapped <H^>
>>>>>> <H^> to H.Qn which you claim, so the behavior specified by the
>>>>>> input is HALTING.
>>>>>>
>>>>>
>>>>> I won't count that as wrong because the part that you got wrong was
>>>>> outside the scope of the original question.
>>>>>
>>>>> You 100% agree with this:
>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> The next step after we agree on that point is:
>>>>> How we measure the actual behavior of the input to embedded_H: ⟨Ĥ⟩
>>>>> ⟨Ĥ⟩ ?
>>>>
>>>>  From the definition of the problem: it is defined as the behavior
>>>> of H^ applied to <H^> or its equivalent of UTM(<H^>,<H^>) and
>>>> nothing else.
>>> Ah so you don't understand enough computer science to know that every
>>> decider implements a computable function that maps its input(s) to an
>>> accept reject state.
>>>
>>> Unless you understand this we cannot proceed. It makes sense that I
>>> apply this same threshold of understanding to all of my reviewers.
>>>
>>
>> No, I understand that perfectly, H needs to compute a mapping from its
>> inputs, but the definition of the mapping, in this case is the Halting
>> Function, which it turns out is NOT directly computatable from the
>> inputs.
>>
>
> Because you tend to weasel word all over the place and have your
> rebuttal ignore what I am currently saying and instead refer to
> something that I said 50 posts ago let's be perfectly clear:
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn

So, no answer?

The FULL statement from Linz, INCLUDING the requirements which you drop
is that, we can derive the following requirements on Ĥ based on the
actual requirements on H.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ IFF Ĥ (Ĥ) Halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn IFF Ĥ (Ĥ) Never Halts

This is from the definition of a Halting Decider that

On 1/15/2022 5:06 AM, Richard Damon wrote:
> On 1/14/22 11:51 PM, olcott wrote:
>> On 1/14/2022 10:34 PM, Richard Damon wrote:
>>> On 1/14/22 11:26 PM, olcott wrote:
>>>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>>>> On 1/14/22 10:44 PM, olcott wrote:
>>>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is the case that the copy of H (called embedded_H) at
>>>>>>>>>>>>>> Ĥ.qx must abort
>>>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would
>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A simulating halt decider simulates N steps of its input
>>>>>>>>>>>>>> until its input
>>>>>>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> --
>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>
>>>>>>>>>>>>> A Turing machine applied to some input reaches one final
>>>>>>>>>>>>> state or one infinite loop, not two different ones. This is
>>>>>>>>>>>>> a consequence of the definition of determinism.
>>>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx
>>>>>>>>>>>> correctly
>>>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>>>>>>>> mathematical
>>>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on
>>>>>>>>>>>> the basis
>>>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested
>>>>>>>>>>>> simulation to the
>>>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>>>> --
>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>
>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>>>> is a question. A question that has only one answer. We can
>>>>>>>>>>> find the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a
>>>>>>>>>>> UTM. Otherwise it is like saying:
>>>>>>>>>>>
>>>>>>>>>>> 2+2 = 4
>>>>>>>>>>> 2+2 = 5
>>>>>>>>>>
>>>>>>>>>> That is not the question and you know it.
>>>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>>>
>>>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except it isn't
>>>>>>>>>
>>>>>>>>> The DEFINITION of a correct H was
>>>>>>>>>
>>>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>>>>>
>>>>>>>>
>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy
>>>>>>>> or Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩
>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> Do you understand that this is correct, or do you not know
>>>>>>>> computer science well enough to understand that this is correct?
>>>>>>>
>>>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^
>>>>>>> applied to <H^> (BY DEFINITION) which goes to H^.Qn and Halts if
>>>>>>> the copy of H in it goes to H.Qn, which it does if H mapped <H^>
>>>>>>> <H^> to H.Qn which you claim, so the behavior specified by the
>>>>>>> input is HALTING.
>>>>>>>
>>>>>>
>>>>>> I won't count that as wrong because the part that you got wrong
>>>>>> was outside the scope of the original question.
>>>>>>
>>>>>> You 100% agree with this:
>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>> The next step after we agree on that point is:
>>>>>> How we measure the actual behavior of the input to embedded_H: ⟨Ĥ⟩
>>>>>> ⟨Ĥ⟩ ?
>>>>>
>>>>>  From the definition of the problem: it is defined as the behavior
>>>>> of H^ applied to <H^> or its equivalent of UTM(<H^>,<H^>) and
>>>>> nothing else.
>>>> Ah so you don't understand enough computer science to know that
>>>> every decider implements a computable function that maps its
>>>> input(s) to an accept reject state.
>>>>
>>>> Unless you understand this we cannot proceed. It makes sense that I
>>>> apply this same threshold of understanding to all of my reviewers.
>>>>
>>>
>>> No, I understand that perfectly, H needs to compute a mapping from
>>> its inputs, but the definition of the mapping, in this case is the
>>> Halting Function, which it turns out is NOT directly computatable
>>> from the inputs.
>>>
>>
>> Because you tend to weasel word all over the place and have your
>> rebuttal ignore what I am currently saying and instead refer to
>> something that I said 50 posts ago let's be perfectly clear:
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>
> So, no answer?
>

On 1/15/22 9:33 AM, olcott wrote:
> On 1/15/2022 5:06 AM, Richard Damon wrote:
>> On 1/14/22 11:51 PM, olcott wrote:
>>> On 1/14/2022 10:34 PM, Richard Damon wrote:
>>>> On 1/14/22 11:26 PM, olcott wrote:
>>>>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>>>>> On 1/14/22 10:44 PM, olcott wrote:
>>>>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is the case that the copy of H (called embedded_H) at
>>>>>>>>>>>>>>> Ĥ.qx must abort
>>>>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would
>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A simulating halt decider simulates N steps of its input
>>>>>>>>>>>>>>> until its input
>>>>>>>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A Turing machine applied to some input reaches one final
>>>>>>>>>>>>>> state or one infinite loop, not two different ones. This
>>>>>>>>>>>>>> is a consequence of the definition of determinism.
>>>>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx
>>>>>>>>>>>>> correctly
>>>>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>>>>>>>>> mathematical
>>>>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven on
>>>>>>>>>>>>> the basis
>>>>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested
>>>>>>>>>>>>> simulation to the
>>>>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>>>>> --
>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>
>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>>>>> is a question. A question that has only one answer. We can
>>>>>>>>>>>> find the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to a
>>>>>>>>>>>> UTM. Otherwise it is like saying:
>>>>>>>>>>>>
>>>>>>>>>>>> 2+2 = 4
>>>>>>>>>>>> 2+2 = 5
>>>>>>>>>>>
>>>>>>>>>>> That is not the question and you know it.
>>>>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>>>>
>>>>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Except it isn't
>>>>>>>>>>
>>>>>>>>>> The DEFINITION of a correct H was
>>>>>>>>>>
>>>>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>> Ĥ.qy or Ĥ.qn based on the actual behavior specified by its
>>>>>>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>> Do you understand that this is correct, or do you not know
>>>>>>>>> computer science well enough to understand that this is correct?
>>>>>>>>
>>>>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^
>>>>>>>> applied to <H^> (BY DEFINITION) which goes to H^.Qn and Halts if
>>>>>>>> the copy of H in it goes to H.Qn, which it does if H mapped <H^>
>>>>>>>> <H^> to H.Qn which you claim, so the behavior specified by the
>>>>>>>> input is HALTING.
>>>>>>>>
>>>>>>>
>>>>>>> I won't count that as wrong because the part that you got wrong
>>>>>>> was outside the scope of the original question.
>>>>>>>
>>>>>>> You 100% agree with this:
>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>> The next step after we agree on that point is:
>>>>>>> How we measure the actual behavior of the input to embedded_H:
>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>>>>>>
>>>>>>  From the definition of the problem: it is defined as the behavior
>>>>>> of H^ applied to <H^> or its equivalent of UTM(<H^>,<H^>) and
>>>>>> nothing else.
>>>>> Ah so you don't understand enough computer science to know that
>>>>> every decider implements a computable function that maps its
>>>>> input(s) to an accept reject state.
>>>>>
>>>>> Unless you understand this we cannot proceed. It makes sense that I
>>>>> apply this same threshold of understanding to all of my reviewers.
>>>>>
>>>>
>>>> No, I understand that perfectly, H needs to compute a mapping from
>>>> its inputs, but the definition of the mapping, in this case is the
>>>> Halting Function, which it turns out is NOT directly computatable
>>>> from the inputs.
>>>>
>>>
>>> Because you tend to weasel word all over the place and have your
>>> rebuttal ignore what I am currently saying and instead refer to
>>> something that I said 50 posts ago let's be perfectly clear:
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>
>> So, no answer?
>>
>
> I am asking whether or not you agree with the above,
> Linz says it in a less precise way that can be misinterpreted.
>
> Unless and until you understand enough computer science to
> know that the way that I said it is correct we cannot proceed.
>
> DO YOU PERFECTLY AGREE THAT THIS IS 100% CORRECT?
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

On 1/15/2022 9:54 AM, Richard Damon wrote:
> On 1/15/22 9:33 AM, olcott wrote:
>> On 1/15/2022 5:06 AM, Richard Damon wrote:
>>> On 1/14/22 11:51 PM, olcott wrote:
>>>> On 1/14/2022 10:34 PM, Richard Damon wrote:
>>>>> On 1/14/22 11:26 PM, olcott wrote:
>>>>>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>>>>>> On 1/14/22 10:44 PM, olcott wrote:
>>>>>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is the case that the copy of H (called embedded_H) at
>>>>>>>>>>>>>>>> Ĥ.qx must abort
>>>>>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A simulating halt decider simulates N steps of its input
>>>>>>>>>>>>>>>> until its input
>>>>>>>>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A Turing machine applied to some input reaches one final
>>>>>>>>>>>>>>> state or one infinite loop, not two different ones. This
>>>>>>>>>>>>>>> is a consequence of the definition of determinism.
>>>>>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx
>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>>>>>>>>>> mathematical
>>>>>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven
>>>>>>>>>>>>>> on the basis
>>>>>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested
>>>>>>>>>>>>>> simulation to the
>>>>>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>>>>>> --
>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>>>>>> is a question. A question that has only one answer. We can
>>>>>>>>>>>>> find the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to
>>>>>>>>>>>>> a UTM. Otherwise it is like saying:
>>>>>>>>>>>>>
>>>>>>>>>>>>> 2+2 = 4
>>>>>>>>>>>>> 2+2 = 5
>>>>>>>>>>>>
>>>>>>>>>>>> That is not the question and you know it.
>>>>>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>>>>>
>>>>>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except it isn't
>>>>>>>>>>>
>>>>>>>>>>> The DEFINITION of a correct H was
>>>>>>>>>>>
>>>>>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>> Ĥ.qy or Ĥ.qn based on the actual behavior specified by its
>>>>>>>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>> Do you understand that this is correct, or do you not know
>>>>>>>>>> computer science well enough to understand that this is correct?
>>>>>>>>>
>>>>>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^
>>>>>>>>> applied to <H^> (BY DEFINITION) which goes to H^.Qn and Halts
>>>>>>>>> if the copy of H in it goes to H.Qn, which it does if H mapped
>>>>>>>>> <H^> <H^> to H.Qn which you claim, so the behavior specified by
>>>>>>>>> the input is HALTING.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I won't count that as wrong because the part that you got wrong
>>>>>>>> was outside the scope of the original question.
>>>>>>>>
>>>>>>>> You 100% agree with this:
>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> The next step after we agree on that point is:
>>>>>>>> How we measure the actual behavior of the input to embedded_H:
>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>>>>>>>
>>>>>>>  From the definition of the problem: it is defined as the
>>>>>>> behavior of H^ applied to <H^> or its equivalent of
>>>>>>> UTM(<H^>,<H^>) and nothing else.
>>>>>> Ah so you don't understand enough computer science to know that
>>>>>> every decider implements a computable function that maps its
>>>>>> input(s) to an accept reject state.
>>>>>>
>>>>>> Unless you understand this we cannot proceed. It makes sense that
>>>>>> I apply this same threshold of understanding to all of my reviewers.
>>>>>>
>>>>>
>>>>> No, I understand that perfectly, H needs to compute a mapping from
>>>>> its inputs, but the definition of the mapping, in this case is the
>>>>> Halting Function, which it turns out is NOT directly computatable
>>>>> from the inputs.
>>>>>
>>>>
>>>> Because you tend to weasel word all over the place and have your
>>>> rebuttal ignore what I am currently saying and instead refer to
>>>> something that I said 50 posts ago let's be perfectly clear:
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>>
>>> So, no answer?
>>>
>>
>> I am asking whether or not you agree with the above,
>> Linz says it in a less precise way that can be misinterpreted.
>>
>> Unless and until you understand enough computer science to
>> know that the way that I said it is correct we cannot proceed.
>>
>> DO YOU PERFECTLY AGREE THAT THIS IS 100% CORRECT?
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> That is a NONSENSE statement without the conditions on it.
>>
>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>
> Right.
>
> AND the input <H^> <H^> is a description of the whole computation being
> preformed.
>
> Note, this puts H in a bind,

On 1/15/22 11:37 AM, olcott wrote:
> On 1/15/2022 9:54 AM, Richard Damon wrote:
>> On 1/15/22 9:33 AM, olcott wrote:
>>> On 1/15/2022 5:06 AM, Richard Damon wrote:
>>>> On 1/14/22 11:51 PM, olcott wrote:
>>>>> On 1/14/2022 10:34 PM, Richard Damon wrote:
>>>>>> On 1/14/22 11:26 PM, olcott wrote:
>>>>>>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>>>>>>> On 1/14/22 10:44 PM, olcott wrote:
>>>>>>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>>>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1,
>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is the case that the copy of H (called embedded_H)
>>>>>>>>>>>>>>>>> at Ĥ.qx must abort
>>>>>>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A simulating halt decider simulates N steps of its
>>>>>>>>>>>>>>>>> input until its input
>>>>>>>>>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A Turing machine applied to some input reaches one final
>>>>>>>>>>>>>>>> state or one infinite loop, not two different ones. This
>>>>>>>>>>>>>>>> is a consequence of the definition of determinism.
>>>>>>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx
>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis that
>>>>>>>>>>>>>>> a mathematical
>>>>>>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven
>>>>>>>>>>>>>>> on the basis
>>>>>>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested
>>>>>>>>>>>>>>> simulation to the
>>>>>>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>>>>>>> is a question. A question that has only one answer. We can
>>>>>>>>>>>>>> find the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to
>>>>>>>>>>>>>> a UTM. Otherwise it is like saying:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 2+2 = 4
>>>>>>>>>>>>>> 2+2 = 5
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is not the question and you know it.
>>>>>>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except it isn't
>>>>>>>>>>>>
>>>>>>>>>>>> The DEFINITION of a correct H was
>>>>>>>>>>>>
>>>>>>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>> Ĥ.qy or Ĥ.qn based on the actual behavior specified by its
>>>>>>>>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>> Do you understand that this is correct, or do you not know
>>>>>>>>>>> computer science well enough to understand that this is correct?
>>>>>>>>>>
>>>>>>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^
>>>>>>>>>> applied to <H^> (BY DEFINITION) which goes to H^.Qn and Halts
>>>>>>>>>> if the copy of H in it goes to H.Qn, which it does if H mapped
>>>>>>>>>> <H^> <H^> to H.Qn which you claim, so the behavior specified
>>>>>>>>>> by the input is HALTING.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I won't count that as wrong because the part that you got wrong
>>>>>>>>> was outside the scope of the original question.
>>>>>>>>>
>>>>>>>>> You 100% agree with this:
>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>> Ĥ.qy or
>>>>>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>> The next step after we agree on that point is:
>>>>>>>>> How we measure the actual behavior of the input to embedded_H:
>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>>>>>>>>
>>>>>>>>  From the definition of the problem: it is defined as the
>>>>>>>> behavior of H^ applied to <H^> or its equivalent of
>>>>>>>> UTM(<H^>,<H^>) and nothing else.
>>>>>>> Ah so you don't understand enough computer science to know that
>>>>>>> every decider implements a computable function that maps its
>>>>>>> input(s) to an accept reject state.
>>>>>>>
>>>>>>> Unless you understand this we cannot proceed. It makes sense that
>>>>>>> I apply this same threshold of understanding to all of my reviewers.
>>>>>>>
>>>>>>
>>>>>> No, I understand that perfectly, H needs to compute a mapping from
>>>>>> its inputs, but the definition of the mapping, in this case is the
>>>>>> Halting Function, which it turns out is NOT directly computatable
>>>>>> from the inputs.
>>>>>>
>>>>>
>>>>> Because you tend to weasel word all over the place and have your
>>>>> rebuttal ignore what I am currently saying and instead refer to
>>>>> something that I said 50 posts ago let's be perfectly clear:
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>>>
>>>> So, no answer?
>>>>
>>>
>>> I am asking whether or not you agree with the above,
>>> Linz says it in a less precise way that can be misinterpreted.
>>>
>>> Unless and until you understand enough computer science to
>>> know that the way that I said it is correct we cannot proceed.
>>>
>>> DO YOU PERFECTLY AGREE THAT THIS IS 100% CORRECT?
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> That is a NONSENSE statement without the conditions on it.
>>>
>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>
>> Right.
>>
>> AND the input <H^> <H^> is a description of the whole computation
>> being preformed.
>>
>> Note, this puts H in a bind,
>
> There is no H, there is only a copy of H at Ĥ.qx that is referred to as
> embedded_H.

On 1/15/2022 11:22 AM, Richard Damon wrote:
> On 1/15/22 11:37 AM, olcott wrote:
>> On 1/15/2022 9:54 AM, Richard Damon wrote:
>>> On 1/15/22 9:33 AM, olcott wrote:
>>>> On 1/15/2022 5:06 AM, Richard Damon wrote:
>>>>> On 1/14/22 11:51 PM, olcott wrote:
>>>>>> On 1/14/2022 10:34 PM, Richard Damon wrote:
>>>>>>> On 1/14/22 11:26 PM, olcott wrote:
>>>>>>>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>> On 1/14/22 10:44 PM, olcott wrote:
>>>>>>>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>>>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is the case that the copy of H (called embedded_H)
>>>>>>>>>>>>>>>>>> at Ĥ.qx must abort
>>>>>>>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A simulating halt decider simulates N steps of its
>>>>>>>>>>>>>>>>>> input until its input
>>>>>>>>>>>>>>>>>> halts on its own or it correctly determines that a
>>>>>>>>>>>>>>>>>> pure simulation of
>>>>>>>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A Turing machine applied to some input reaches one
>>>>>>>>>>>>>>>>> final state or one infinite loop, not two different
>>>>>>>>>>>>>>>>> ones. This is a consequence of the definition of
>>>>>>>>>>>>>>>>> determinism.
>>>>>>>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx
>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis that
>>>>>>>>>>>>>>>> a mathematical
>>>>>>>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven
>>>>>>>>>>>>>>>> on the basis
>>>>>>>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested
>>>>>>>>>>>>>>>> simulation to the
>>>>>>>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>>>>>>>> is a question. A question that has only one answer. We
>>>>>>>>>>>>>>> can find the answer by passing the arguments ⟨Ĥ.q0⟩ and
>>>>>>>>>>>>>>> ⟨Ĥ⟩ to a UTM. Otherwise it is like saying:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 2+2 = 4
>>>>>>>>>>>>>>> 2+2 = 5
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is not the question and you know it.
>>>>>>>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except it isn't
>>>>>>>>>>>>>
>>>>>>>>>>>>> The DEFINITION of a correct H was
>>>>>>>>>>>>>
>>>>>>>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>>> Ĥ.qy or Ĥ.qn based on the actual behavior specified by its
>>>>>>>>>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>> Do you understand that this is correct, or do you not know
>>>>>>>>>>>> computer science well enough to understand that this is
>>>>>>>>>>>> correct?
>>>>>>>>>>>
>>>>>>>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as
>>>>>>>>>>> H^ applied to <H^> (BY DEFINITION) which goes to H^.Qn and
>>>>>>>>>>> Halts if the copy of H in it goes to H.Qn, which it does if H
>>>>>>>>>>> mapped <H^> <H^> to H.Qn which you claim, so the behavior
>>>>>>>>>>> specified by the input is HALTING.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I won't count that as wrong because the part that you got
>>>>>>>>>> wrong was outside the scope of the original question.
>>>>>>>>>>
>>>>>>>>>> You 100% agree with this:
>>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>> Ĥ.qy or
>>>>>>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>> The next step after we agree on that point is:
>>>>>>>>>> How we measure the actual behavior of the input to embedded_H:
>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>>>>>>>>>
>>>>>>>>>  From the definition of the problem: it is defined as the
>>>>>>>>> behavior of H^ applied to <H^> or its equivalent of
>>>>>>>>> UTM(<H^>,<H^>) and nothing else.
>>>>>>>> Ah so you don't understand enough computer science to know that
>>>>>>>> every decider implements a computable function that maps its
>>>>>>>> input(s) to an accept reject state.
>>>>>>>>
>>>>>>>> Unless you understand this we cannot proceed. It makes sense
>>>>>>>> that I apply this same threshold of understanding to all of my
>>>>>>>> reviewers.
>>>>>>>>
>>>>>>>
>>>>>>> No, I understand that perfectly, H needs to compute a mapping
>>>>>>> from its inputs, but the definition of the mapping, in this case
>>>>>>> is the Halting Function, which it turns out is NOT directly
>>>>>>> computatable from the inputs.
>>>>>>>
>>>>>>
>>>>>> Because you tend to weasel word all over the place and have your
>>>>>> rebuttal ignore what I am currently saying and instead refer to
>>>>>> something that I said 50 posts ago let's be perfectly clear:
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>>>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>>>>
>>>>> So, no answer?
>>>>>
>>>>
>>>> I am asking whether or not you agree with the above,
>>>> Linz says it in a less precise way that can be misinterpreted.
>>>>
>>>> Unless and until you understand enough computer science to
>>>> know that the way that I said it is correct we cannot proceed.
>>>>
>>>> DO YOU PERFECTLY AGREE THAT THIS IS 100% CORRECT?
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> That is a NONSENSE statement without the conditions on it.
>>>>
>>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>>
>>> Right.
>>>
>>> AND the input <H^> <H^> is a description of the whole computation
>>> being preformed.
>>>
>>> Note, this puts H in a bind,
>>
>> There is no H, there is only a copy of H at Ĥ.qx that is referred to
>> as embedded_H.
>
> And you are wrong there. The HAD to be an H first to build H^ from.
>
> H is the decider that you want to make the CLAIM to be a correct Halting
> Decider.
>

On 1/15/22 12:44 PM, olcott wrote:
> On 1/15/2022 11:22 AM, Richard Damon wrote:
>> On 1/15/22 11:37 AM, olcott wrote:
>>> On 1/15/2022 9:54 AM, Richard Damon wrote:
>>>> On 1/15/22 9:33 AM, olcott wrote:
>>>>> On 1/15/2022 5:06 AM, Richard Damon wrote:
>>>>>> On 1/14/22 11:51 PM, olcott wrote:
>>>>>>> On 1/14/2022 10:34 PM, Richard Damon wrote:
>>>>>>>> On 1/14/22 11:26 PM, olcott wrote:
>>>>>>>>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>>> On 1/14/22 10:44 PM, olcott wrote:
>>>>>>>>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>>>>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1,
>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is the case that the copy of H (called embedded_H)
>>>>>>>>>>>>>>>>>>> at Ĥ.qx must abort
>>>>>>>>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A simulating halt decider simulates N steps of its
>>>>>>>>>>>>>>>>>>> input until its input
>>>>>>>>>>>>>>>>>>> halts on its own or it correctly determines that a
>>>>>>>>>>>>>>>>>>> pure simulation of
>>>>>>>>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 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)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A Turing machine applied to some input reaches one
>>>>>>>>>>>>>>>>>> final state or one infinite loop, not two different
>>>>>>>>>>>>>>>>>> ones. This is a consequence of the definition of
>>>>>>>>>>>>>>>>>> determinism.
>>>>>>>>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at
>>>>>>>>>>>>>>>>> Ĥ.qx correctly
>>>>>>>>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis
>>>>>>>>>>>>>>>>> that a mathematical
>>>>>>>>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is
>>>>>>>>>>>>>>>>> proven on the basis
>>>>>>>>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested
>>>>>>>>>>>>>>>>> simulation to the
>>>>>>>>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>>>>>>>>> is a question. A question that has only one answer. We
>>>>>>>>>>>>>>>> can find the answer by passing the arguments ⟨Ĥ.q0⟩ and
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ to a UTM. Otherwise it is like saying:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 2+2 = 4
>>>>>>>>>>>>>>>> 2+2 = 5
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is not the question and you know it.
>>>>>>>>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except it isn't
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The DEFINITION of a correct H was
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it
>>>>>>>>>>>>>> does)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>>>> Ĥ.qy or Ĥ.qn based on the actual behavior specified by its
>>>>>>>>>>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Do you understand that this is correct, or do you not know
>>>>>>>>>>>>> computer science well enough to understand that this is
>>>>>>>>>>>>> correct?
>>>>>>>>>>>>
>>>>>>>>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as
>>>>>>>>>>>> H^ applied to <H^> (BY DEFINITION) which goes to H^.Qn and
>>>>>>>>>>>> Halts if the copy of H in it goes to H.Qn, which it does if
>>>>>>>>>>>> H mapped <H^> <H^> to H.Qn which you claim, so the behavior
>>>>>>>>>>>> specified by the input is HALTING.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I won't count that as wrong because the part that you got
>>>>>>>>>>> wrong was outside the scope of the original question.
>>>>>>>>>>>
>>>>>>>>>>> You 100% agree with this:
>>>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>> Ĥ.qy or
>>>>>>>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>> The next step after we agree on that point is:
>>>>>>>>>>> How we measure the actual behavior of the input to
>>>>>>>>>>> embedded_H: ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>>>>>>>>>>
>>>>>>>>>>  From the definition of the problem: it is defined as the
>>>>>>>>>> behavior of H^ applied to <H^> or its equivalent of
>>>>>>>>>> UTM(<H^>,<H^>) and nothing else.
>>>>>>>>> Ah so you don't understand enough computer science to know that
>>>>>>>>> every decider implements a computable function that maps its
>>>>>>>>> input(s) to an accept reject state.
>>>>>>>>>
>>>>>>>>> Unless you understand this we cannot proceed. It makes sense
>>>>>>>>> that I apply this same threshold of understanding to all of my
>>>>>>>>> reviewers.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, I understand that perfectly, H needs to compute a mapping
>>>>>>>> from its inputs, but the definition of the mapping, in this case
>>>>>>>> is the Halting Function, which it turns out is NOT directly
>>>>>>>> computatable from the inputs.
>>>>>>>>
>>>>>>>
>>>>>>> Because you tend to weasel word all over the place and have your
>>>>>>> rebuttal ignore what I am currently saying and instead refer to
>>>>>>> something that I said 50 posts ago let's be perfectly clear:
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>>>>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>>>>>
>>>>>> So, no answer?
>>>>>>
>>>>>
>>>>> I am asking whether or not you agree with the above,
>>>>> Linz says it in a less precise way that can be misinterpreted.
>>>>>
>>>>> Unless and until you understand enough computer science to
>>>>> know that the way that I said it is correct we cannot proceed.
>>>>>
>>>>> DO YOU PERFECTLY AGREE THAT THIS IS 100% CORRECT?
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> That is a NONSENSE statement without the conditions on it.
>>>>>
>>>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>>>
>>>> Right.
>>>>
>>>> AND the input <H^> <H^> is a description of the whole computation
>>>> being preformed.
>>>>
>>>> Note, this puts H in a bind,
>>>
>>> There is no H, there is only a copy of H at Ĥ.qx that is referred to
>>> as embedded_H.
>>
>> And you are wrong there. The HAD to be an H first to build H^ from.
>>
>> H is the decider that you want to make the CLAIM to be a correct
>> Halting Decider.
>>
>
> I wanted to make it clear that the subject of  the discussion is not H
> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. The subject of the discussion is embedded_H applied
> to ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> It seems that you apply great skill and creativity to make sure that you
> always refer to things that are not being discussed.
>
>> If you are willing to stipulate that there is no such machine, fine,
>> that mean you concede the question.
>>
>> You seem to have forgotten what you are trying to do.
>>
>> You DO underestand that you can have more than 1 Turing Machine in
>> existence at a time, they all run independently, but more than one do
>> exist.
>>
>>>
>>>>  if its algorithm decides that this input should take it to the Qn
>>>> state, then the actual behavior of the computatiion this input
>>>> represents will be HALTING
>>>
>>> There is no "represents", there is only the actual behavior specified by
>>> the actual input to embedded_H: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>>
>> And what 'behavior' does a string of symbol have?
>>
>> How did we get that string of symbols?
>>
>
> The behavior specified by a string of symbols is the actual behavior of
> the simulation of this string of symbols.