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. You just keep looking at the WRONG behavior.

You don't look at <H^> <H^> and what it represents (H^ applied to <H^>)
but to the behavior of H

>
> You reasoning goes like this: We know that a dog is an animal and we
> know that a cat is an animal therefore a dog is a cat.
>

Nope (invalid analogy), YOUR reasoning is we got off the highway at mile
5, and the highway kept going, so as far as we know, the highway will
never end.

You are just showing you don't know how to actually prove something.

FAIL.