On 4/9/22 5:00 PM, olcott wrote:
> On 4/9/2022 3:55 PM, Richard Damon wrote:
>> On 4/9/22 4:18 PM, olcott wrote:
>>> On 4/9/2022 3:13 PM, Richard Damon wrote:
>>>> On 4/9/22 3:49 PM, olcott wrote:
>>>>> On 4/9/2022 2:42 PM, Richard Damon wrote:
>>>>>> On 4/9/22 3:30 PM, olcott wrote:
>>>>>>> On 4/9/2022 2:22 PM, Richard Damon wrote:
>>>>>>>> On 4/9/22 2:58 PM, olcott wrote:
>>>>>>>>> On 4/9/2022 1:53 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 4/9/22 2:31 PM, olcott wrote:
>>>>>>>>>>> On 4/9/2022 1:24 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 4/9/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>> On 4/9/2022 10:17 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/9/22 10:43 AM, olcott wrote:
>>>>>>>>>>>>>>> On 4/9/2022 7:28 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I tell one tiny piece of the truth until someone gets
>>>>>>>>>>>>>>>>> it. Then I move
>>>>>>>>>>>>>>>>> on to the next tiny piece of the truth until someone
>>>>>>>>>>>>>>>>> gets it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Oh pull the other one, it's got bells on!  Actually, you
>>>>>>>>>>>>>>>> often tell
>>>>>>>>>>>>>>>> massive whoppers and then spend months backpedalling.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.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⟩
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Explain exactly how the actual input: ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
>>>>>>>>>>>>>>> embedded_H reaches its own final state: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your right, it doesn't in THAT case,
>>>>>>>>>>>>>
>>>>>>>>>>>>> and when embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ it
>>>>>>>>>>>>> still never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, while embedded_H's simulation never reached thqt
>>>>>>>>>>>> state, that doesn't matter,
>>>>>>>>>>> Because the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H would
>>>>>>>>>>> never reach its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under
>>>>>>>>>>> any condition what-so-ever it is by logical necessity that
>>>>>>>>>>> embedded_H would be correct to transition to its own reject
>>>>>>>>>>> state.
>>>>>>>>>>
>>>>>>>>>> No, that is NOT true. The CORRECT simulation of the input to
>>>>>>>>>> embedded_H DOES reach its final state if embedded_H goes to
>>>>>>>>>> its non-halting answer state. This has been established. This
>>>>>>>>>> is the condition that Halting looks at.
>>>>>>>>>
>>>>>>>>> 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⟩
>>>>>>>>>
>>>>>>>>> then embedded_H aborts its simulation of ⟨Ĥ0⟩ ⟨Ĥ1⟩ causing this
>>>>>>>>> simulated input to immediately stop never ever reaching its own
>>>>>>>>> final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, and simulator that aborts its simulation my terminate its
>>>>>>>> own action, but does NOT change the behavior of the input,
>>>>>>>
>>>>>>> It is ridiculously stupid to believe that an aborted simulation
>>>>>>> keeps running after it have been aborted.
>>>>>>>
>>>>>>
>>>>>> You just aren't understanding the words.
>>>>>>
>>>>>> I am not saying the ABORTED simulation continues, but the CORRECT
>>>>>> simulation and the actual machine behavior do, by definition.
>>>>>
>>>>> Under no circumstances what-so-ever does the simulated input ⟨Ĥ0⟩
>>>>> ⟨Ĥ1⟩ to embedded_H meet this Linz criteria of a halting computation:
>>>>
>>>> That is just a LIE based on NOT looking at an ACTUAL CORRECT
>>>> simulation of the input.
>>>>
>>>> The ACTUAL behavior of the input to H / embedded_H, the input string
>>>> <H^> <H^> has been PROVEN to Halt if H / embedded_H reject that
>>>> input and go to Qn.
>>>>
>>>>
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> Which means the ACTUAL TURING MACHINE, not a simulation.
>>>>
>>>> For this definition, the ONLY thing that the input <H^> <H^> looks
>>>> at is the actual computation H^ applied to <H^> PERIOD, DEFINITION.
>>>>
>>>> Anythibng else can only be used by first showing actual equivalence
>>>> to that DEFINITION.
>>>>
>>>> The 'simulation' of the input by H / embedded_H FAILS to meet that
>>>> equivalence test if it aborts its simulation, so is irrelevent.
>>>>
>>>>>
>>>>> Therefore people that do not have severe brain damage will
>>>>> understand that embedded_H would be correct to reject this input as
>>>>> non-halting.
>>>>>
>>>>
>>>> Nope. That you don't understand it just shows that you are the
>>>> strawman and don't have a brain.
>>>>
>>>> Remember the DEFINITION of the correct answer is:
>>>
>>> The computation of the mapping of the inputs to an accept or reject
>>> state based on the actual behavior of these actual inputs.
>>
>> Right, and the "ACTUAL BEHAVIOR of the input" <H^> <H^< is BY
>> DEFINITION the behavior of H^ applid to <H^>.
>>
>> Remember Definition 12.1 H applied to <M> w -> Qy if M applied to w
>> Halts and -> Qn if M applied to w never halts. Thus the 'behavior'
>> that H decides on is the behavior of the machine describe by its input.
>>
>> You keep on wanting to look at the behavior of the simulation by H of
>> its input instead of the actual behavior of the input to H.
>>
>> The 'input' is JUST the <H^> <H^> and makes NO reference to H (or
>> embedded_H) and actually needs to be independent of the machine that
>> is looking at it.
>>
>>>
>>> The actual behavior of the actual input never meets the Linz
>>> definition of halting under any condition what-so-ever thus is
>>> correctly judged as a non-halting input.
>>
>> But it does.
>
> The actual input is ⟨Ĥ0⟩ ⟨Ĥ1⟩.

But ALL <H^i> are the exact same string, so ALL copies act the same.

>
> The actual behavior of this input is non-halting and you already
> admitted this.

Nope, I have PROVED that it is halting if H rejects this input.

>
> Therefore you are a God damned liar.
>

YOU are the LIAR, and DAMNED by God, and I think you know it but hide
the truth from yourself by enforcing ignorance and stupidity on yourself.

I speak from the DEFINITIONS, you speak out of the fantasies of your mind.

FAIL.