On 4/9/22 2:32 PM, olcott wrote:
> On 4/9/2022 1:28 PM, Richard Damon wrote:
>>
>> On 4/9/22 11:25 AM, olcott wrote:
>>> On 4/9/2022 10:20 AM, Richard Damon wrote:
>>>> On 4/9/22 10:41 AM, olcott wrote:
>>>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>>>> never possibly reach its own final state under any
>>>>>>>>>>>>>>> condition at all.
>>>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject its
>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because I absolutely positively will not tolerate
>>>>>>>>>>>>> divergence from
>>>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>>>
>>>>>>>>>>>> But you have no choice but to tolerate it.  If someone wants
>>>>>>>>>>>> to talk
>>>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>>>
>>>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) ==
>>>>>>>>>>>> false but P(P)
>>>>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>>>>> transitions to
>>>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel
>>>>>>>>>>>> free to deny
>>>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>>>
>>>>>>>>>>> If you believe (against the verified facts) that the
>>>>>>>>>>> simulated ⟨Ĥ0⟩
>>>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>>>
>>>>>>>>>> I believe what you've told me: that you claim that
>>>>>>>>>> H(P,P)==false is
>>>>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>>>>
>>>>>>>>> If the input to H(P,P) cannot possibly reach its final state
>>>>>>>>> then this
>>>>>>>>> input is correctly rejected and nothing in the universe can
>>>>>>>>> possibly
>>>>>>>>> contradict this.
>>>>>>>>
>>>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You don't
>>>>>>>> dispute
>>>>>>>> either (indeed they come from you).
>>>>>>
>>>>>> At least you don't contend these facts.
>>>>>>
>>>>>>>> Your new line in waffle is just an attempt to distract attention
>>>>>>>> from a
>>>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>>>
>>>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>>>
>>>>>>> A halt decider must compute the mapping from its inputs (not any
>>>>>>> damn
>>>>>>> thing else in the universe) to its own final state on the basis
>>>>>>> of the
>>>>>>> behavior specified by these inputs
>>>>>>
>>>>>> That's not counter intuitive, it's basic.  Everyone knows this,
>>>>>> though
>>>>>> it took you a while to get round to it.  A halt decider accepts or
>>>>>> rejects a string based on the behaviour of the computation
>>>>>> specified by
>>>>>> that string.  Of course, you never got as far in my exercises as
>>>>>> specifying any TM that decides something on the basis of
>>>>>> behaviour, so
>>>>>> you really don't know how it's actually done.  That was, I
>>>>>> thought, the
>>>>>> whole point of the exercises -- to see how TMs are specified to
>>>>>> decide
>>>>>> properties of computations.
>>>>>>
>>>>>
>>>>> You have to actually pay attention to this, it is the key gap in
>>>>> your reasoning. The following proves that the simulated input ⟨Ĥ0⟩
>>>>> ⟨Ĥ1⟩ to embedded_H cannot possibly reach its own final state under
>>>>> any condition what-so-ever.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>> Then these steps would keep repeating:
>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>
>>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
>>>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it
>>>>> is non-halting.
>>>>
>>>> Right, if embedded_H never goes to Qn
>>>
>>> It never goes to Qn because there is no Qn, you might as well have
>>> said if embedded_H goes to Disneyland, why is it so difficult for you
>>> to get the details exactly right?
>>
>> Then it isn't the required decider!!!!
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn
> There is no Qn it is called H.qn2.1
> There is no Qn it is called H.qn
>

Maybe you should read your source material.

In H the states are called q0, qy, and qn (the q being normal case, the
following letter a subscript)

I capitalize the q to make it clear from the subscript

Read Definition 12.1

There is no embedded_H, the only machines HE talks about are H, the
actual decider; H', the decider with a loop tagged to the end to the Qy
state and ends up in H'(infinity) (non-halting) and H'qn, and H^ which
adds a duplication stage in front, starting at a NEW q0, going to a H^q0
which is the q0 of H and H', and ends in H^(infinity) (non-halting) or
H^.qn (final)

If you can't understand the notation of just 'Qn' to mean whichever
version we are talking about (since all are the same point in the
sequence) you are just too dumb to reason with.

YOU are the one with the major notional errors since the machine with
the infinite loop added is NEVER called a decider, but is an
intermediary step in the construction of H^.

The fact that you focus on this, just shows how weak your point is.

It is an easily established fact, that has been shown to you MANY times,
that if H / embedded_H or what ever you want to call that copy of the
algorithm goes to the state that indicates non-halting, that the H^
Turing Machine that includes that copy IMMEDIATELY Halts.

Thus H^ applied to <H^> IS A HALTING COMPUTATION if H / embedded_H or
whatever you are going to call it answers non-halting, and thus you
decider is just WRONG.

ALL you proof trying to show that H^ is non-halting are just showing
cases where your decider (H, embedded_H or whatever) FAILS to decide,
and is thus FAILED as a decider, and can't be a counter example.

Soethings you try to invoke 'magic' and have that decider suddenly
change itself (which is impossible) and sometimes you just have two
different machines you call 'your decider' which is just lying. (a given
machine always acts the same way).

You need to stop lying about what is happening and admit to yourself
what is actually true.

Youy have wasted 17 years of your life (as it sounds) and are going to
just die with the legacy of a lying kook. Repent and do something
actually useful.