On 4/9/22 5:16 PM, olcott wrote:
> On 4/9/2022 4:11 PM, Richard Damon wrote:
>>
>> 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.
>
> 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 rejects ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Show how ⟨Ĥ0⟩ reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
>
Remember ALL <H^i> are the same, so we can look at the above and see
that the ACTUAL BEHAVIOR of <H^0> <H^1> would be:

H^0 is applied to <H^1>
H0 copies its input <H^1) to <H^2> then
H0 simulates <H^1> <H^2>
H0 THINKS these keep repeating (but they don't)
H^1 copies its input <H^2> to <H^3> then H1 simulates <H^2> <H^3>
H^2 copies its input <H^3> to <H^4> then H2 simulates <H^3> <H^4>
Then embedded_H0 rejects <H^1> <H^2>
going to your H.Qn
This is also H^0.Qn which is a final state of the machine H^0

H^0 applied to <H^1> is thus a HALTING COMPUTATION, and thus so the
input <H^0><H^1> represents one.

Note, behavior of the input is BY DEFINITION based on the behavior of
the ACTUAL MACHINE (or ACTUAL UTM Simulation) NOT the aborted simulation
of the decider.

Thus, embedded_H was WRONG to decide to reject, because it was WRONG to
presume the steps would keep on repating forever because it ignored the
conditionals inside the copies of the embedded_H it was simulating.