On 3/26/2022 10:50 AM, Richard Damon wrote:
> On 3/26/22 11:25 AM, olcott wrote:
>> On 3/26/2022 9:56 AM, Richard Damon wrote:
>>>
>>> On 3/26/22 10:13 AM, olcott wrote:
>>>> On 3/26/2022 8:55 AM, Richard Damon wrote:
>>>>> On 3/26/22 9:44 AM, olcott wrote:
>>>>>> On 3/26/2022 8:24 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 3/26/22 9:14 AM, olcott wrote:
>>>>>>>> On 3/26/2022 8:11 AM, Richard Damon wrote:
>>>>>>>>> On 3/26/22 9:04 AM, olcott wrote:
>>>>>>>>>> On 3/26/2022 5:18 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/25/22 11:58 PM, olcott wrote:
>>>>>>>>>>>> On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A SHD computes the mapping from its input to its own
>>>>>>>>>>>>>>>> accept or reject
>>>>>>>>>>>>>>>> state based on whether or not the pure simulation of its
>>>>>>>>>>>>>>>> simulated
>>>>>>>>>>>>>>>> input could reach its own final state in a finite number
>>>>>>>>>>>>>>>> of simulated
>>>>>>>>>>>>>>>> steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The following simplifies the syntax for the definition
>>>>>>>>>>>>>>>> of the Linz
>>>>>>>>>>>>>>>> Turing machine Ĥ, it is now a single machine with a
>>>>>>>>>>>>>>>> single start
>>>>>>>>>>>>>>>> state.  A copy of Linz H is embedded at Ĥ.qx
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>> reach its final
>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>> Or, more simply, use Linz's condition: if Ĥ applied to
>>>>>>>>>>>>>>> ⟨Ĥ⟩ halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No it turns out to be the case that a halt decider is not
>>>>>>>>>>>>>> allowed to
>>>>>>>>>>>>>> report on its own behavior because itself is neither an
>>>>>>>>>>>>>> input nor a
>>>>>>>>>>>>>> finite string.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No.  Happy to answer questions about why this is wrong, but
>>>>>>>>>>>>> since you
>>>>>>>>>>>>> have not grasped what a halt decider is after 17 years, I
>>>>>>>>>>>>> don't think
>>>>>>>>>>>>> it's worth my while just writing it out yet again.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are agreed that a decider maps its input finite string
>>>>>>>>>>>> input to an accept or reject state.
>>>>>>>>>>>>
>>>>>>>>>>>> Now you are contradicting yourself by saying that a decider
>>>>>>>>>>>> maps a non-input non-finite string.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, what it is mapping is the input <H^> <H^> which most
>>>>>>>>>>> definitely IS a finite string input.
>>>>>>>>>>>
>>>>>>>>>>> It is to map it to Qy (accept) or Qn (reject) based on if the
>>>>>>>>>>> machine H^   applied to <H^> Halts.
>>>>>>>>>>>
>>>>>>>>>>> The fact tha H^ applied to <H^> isn't exactly an input if fine,
>>>>>>>>>>
>>>>>>>>>> I am looking for white dogs in my kitchen by looking for black
>>>>>>>>>> cats in my living room.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, EXACTLY. YOU ARE. This is because you aren't using the
>>>>>>>>> right definition of HALTING. (Halting is the white dog, your
>>>>>>>>> POOP is the black cats).
>>>>>>>>>
>>>>>>>>> Halting is DEFINED based on the behavoir of the TURING MACHINE
>>>>>>>>> that the input represents, NOT a simulation of the input by the
>>>>>>>>> decider.
>>>>>>>>
>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>>>> its own final state. Every distraction away from this point is a
>>>>>>>> dishonest dodge.
>>>>>>>>
>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>>>> its own final state. Every distraction away from this point is a
>>>>>>>> dishonest dodge.
>>>>>>>>
>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>>>> its own final state. Every distraction away from this point is a
>>>>>>>> dishonest dodge.
>>>>>>>>
>>>>>>>> The only correct halt status criteria for a simulating halt
>>>>>>>> decider is whether or not the simulated input can possibly reach
>>>>>>>> its own final state. Every distraction away from this point is a
>>>>>>>> dishonest dodge.
>>>>>>>>
>>>>>>>
>>>>>>> Nope. THE DEFINITION of the right answer is what the ACTUAL
>>>>>>> TURING MACHINE the input represents does.
>>>>>>>
>>>>>>
>>>>>> The actual behavior of the actual simulated input it what counts.
>>>>>
>>>>> NOPE. READ THE DEFINITION!
>>>>>
>>>>> It is the behavior of the ACTUAL TURING MACHINE THE INPUT REPRESENT.
>>>>
>>>> This only means that it is not the behavior of a finite string
>>>> because finite strings have no behavior.
>>>
>>> Right Finite strings have no behavior.
>>>
>>> The behavior the decider needs to decide on is the Turing Machine the
>>> input is a representation of.
>>>
>>
>> The behavior of the UTM simulation of the input is the behavior that
>> this input specifies. That the input simulated by a UTM would never
>> reach its final state conclusively proves that this input specifies a
>> non-halting sequence of configurations.
>
> except that if H <H^> <H^> -> Qn, then H^ <H^> and UTM <H^> <H^> will
> also gp tp H^.Qn and halt, so your claim is a LIE.
>
> Eitehr you LIE that your deicder said its input was non-halting, or you
> LIE that simulation does not reach a final state.
>
> You can't use two different version of H/embedded_H here.
>>
>>>>
>>>> The behavior referred to must be the same as the behavior of the
>>>> simulated Turing machine description otherwise you are denying the
>>>> computational equivalence of the direct execution of a Turing
>>>> machine and the UTM simulation of the machine description of this
>>>> same machine.
>>>
>>> Right, the behavior of the ACTUAL Turing Machine, which can also be
>>> obtained by the simulation with a UTM
>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>> final state.
>>>
>>> NOT 'by embedded_H' but by a UTM. Wrong Definition.
>>>
>>
>> By the UTM aspect of embedded_H because the simulation must occur at
>> the same point (in the middle) of Ĥ where embedded_H is located.
>
> Nope!!!
>
> It is the INDEPENDENT running of UTM <H^> <H^>.
>

THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
THAT IS FALSE THERE IS A KEY DEPENDENCY !!!

The invocation of Ĥ ⟨Ĥ⟩ is the first invocation in what would otherwise
be infinite recursion.

Its normal behavior depends on a subsequent invocation being aborted.

If a subsequent invocation is never aborted then the recursion remains
infinite.

In any case the simulated input never reaches the final state of this
simulated input. The final state of the simulated input is ⟨Ĥ.qn⟩.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer