On 3/26/2022 11:35 AM, Richard Damon wrote:
>
> On 3/26/22 12:12 PM, olcott wrote:
>> 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⟩.
>>
>>
>
> Nope, ALL Copies of the same machine given the same input behave the same.
>

There is never any case where the simulated input reaches its own final
state ⟨Ĥ.qn⟩.

> If you want to refute that, provide and ACTUAL coded example.
>
> H^ applied to <H^> -> H^.Qn and Halts and UTM <H^> <H^> goes to <H^>.Qn
> and Halts if H/embedded_H -> Qn, and if H doesn't, it fails to be a
> decider, so is wrong either way.

Ĥ ⟨Ĥ⟩ and embedded_H both reach their final state of Ĥ.qn and halt.

The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never reaches its own final
state ⟨Ĥ.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