On 3/23/2022 9:31 PM, Richard Damon wrote:
>
> On 3/23/22 10:01 PM, olcott wrote:
>> On 3/23/2022 8:39 PM, Richard Damon wrote:
>>> On 3/23/22 9:29 PM, olcott wrote:
>>>> 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.
>>>>
>>>>
>>>
>>> Almost, it must map the INPUT <H^> <H^> to an OUTPUT Qy or Qn, based
>>> on the FUNCTION it is computing.
>>>
>>> There is NO requirement that it be based on its on simulation, or
>>> only N steps of a UTM.
>>>
>>
>> None-the-less if the behavior that is being measured is not exactly
>> the same behavior as the UTM simulation of the input then the behavior
>> being measured is measured incorrectly.
>>
>> A finite number of N steps is a mandatory constraint otherwise it
>> would be OK to report that infinite execution never halts after an
>> infinite number of steps.
>>
>
> You logic is backwards. You are just showing why it CAN'T be done, not
> why it must not be defined that way.
>
> The behavior that is measured MUST be exactly the behavior of the UTM
> simulation,

In other words your requirement for a halt decider is that it sometimes
never halts.

--
Copyright 2021 Pete Olcott

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