On 3/23/2022 7:15 PM, Richard Damon wrote:
> On 3/23/22 7:50 PM, olcott wrote:
>> On 3/23/2022 6:26 PM, Richard Damon wrote:
>>> On 3/23/22 7:20 PM, olcott wrote:
>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> never reach its
>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>> and
>>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its
>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>>>>> halts"
>>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking about
>>>>>>>>>>>>> Turing
>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>>>> Turing machine
>>>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>>>> identical state
>>>>>>>>>>> transition functions can entail different configuration
>>>>>>>>>>> sequences for
>>>>>>>>>>> the same input.  Nothing you say has any relevance to Linz's
>>>>>>>>>>> Turing
>>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>>
>>>>>>>>>> That your only rebuttal to what I say now is dredging up what
>>>>>>>>>> I said
>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>>
>>>>>>>>> You said this:
>>>>>>>>>
>>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>> never halts.
>>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>
>>>>>>>>
>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must
>>>>>>>> derive the same result. They are not identical final strings.
>>>>>>>>
>>>>>>>>> four days ago and you haven't retracted it.  Until you do, when
>>>>>>>>> you
>>>>>>>>> write Ĥ your readers must assume that you are referring to
>>>>>>>>> something
>>>>>>>>> about which this quote applies.
>>>>>>>>>
>>>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ
>>>>>>>>> you must
>>>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>>>> i.e. that if
>>>>>>>>>
>>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>
>>>>>>>>> then
>>>>>>>>>
>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>>
>>>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>>>> Linz's H and
>>>>>>>>> Ĥ?
>>>>>>>>>
>>>>>>>>
>>>>>>>> You you continue to say that you believe that a decider must
>>>>>>>> report on its own behavior when you already know damn well that
>>>>>>>> a decider only computes the mapping from its inputs to its own
>>>>>>>> final state.
>>>>>>>
>>>>>>> A Decider must report on its own behavior (or the behavior of a
>>>>>>> copy of it) if that is what the input asks for.
>>>>>>>
>>>>>> You know that a decider only computes the mapping from its input
>>>>>> finite strings to its own final state thus you know that you lie
>>>>>> what you say that a decider must compute the mapping from a
>>>>>> non-finite sting non-input.
>>>>>>
>>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>>
>>>>>
>>>>> I don't, but you seem to like to.
>>>>>
>>>>> I never said that H needs to compute a mapping of anything but what
>>>>> has been given as an input.
>>>>>
>>>>> The only thing H needs to compute the mapping of is <H^> <H^>,
>>>>> which is EXACTLY the string on its input.
>>>>>
>>>>> The problem which you don't seem to understand is that the MAPPING
>>>>> it needs to try and compute (and which is not guaranteed to BE
>>>>> Computable), is the Behavior of the machine it represents, H^
>>>>> applied to <H^>, as that is the mapping of the Halting Function.
>>>>
>>>> That is a non finite string non input, so you lied.
>>>>
>>>
>>> <H^> <H^> is a finite string, which is what needs to be mapped, so
>>> you are just lying.
>>>
>>
>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>  > the MAPPING it needs to try and compute (and which is
>>  > not guaranteed to BE Computable), is the Behavior of
>>  > the machine it represents, H^ applied to <H^>,
>>
>> So you are just bald faced liar then.
>> It does not map H^ applied to <H^> to anything.
>> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>
>>
>
> I never said it did.
>
> It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
> FUNCTION) whether H^ applied to <H^> will Halt.

It must map the input to an accept or reject state based on the actual
behavior actually specified by this input as measured by N steps of the
correct UTM simulation of this input.

--
Copyright 2021 Pete Olcott

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