On 4/9/22 5:42 PM, olcott wrote:
> On 4/9/2022 4:34 PM, Richard Damon wrote:
>>
>> 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>
>
> You can't even pay attention to the facts.
> embedded_H0 does not reject any damn thing I already specified that the
> only rejection is embedded_H rejects ⟨Ĥ0⟩ ⟨Ĥ1⟩.
>

Then you just don't understand the basic property of Turing Machines
that all copies behave the same.

If embedded_H does something, then its identical twin embedded_H0 does
exactly the same thing when given the identical input.

You apparently aren't dealing with Turing Machines if this property
doesn't hold, and thus everything you say is meaningless.

If you want to disagree with that basic property, please provide an
ACTUAL example, as an ACTUAL Turing Machine and ACTUAL input.

Oh, I forgot, you don't know how to do that (or at least it seems so) so
that may be hard.

I guess you have just disqualified yourself from talking about Turing
Machines since you don't accept their basic definition and can't prove
that you alternate is actually true.

FAIL.