On 3/24/2022 10:31 AM, Mr Flibble wrote:
> On Thu, 24 Mar 2022 11:30:31 -0400
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 3/24/22 10:57 AM, olcott wrote:
>>> On 3/24/2022 6:12 AM, Richard Damon wrote:
>>>> On 3/23/22 11:05 PM, olcott wrote:
>>>>> 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.
>>>>>
>>>>
>>>> Again, you are mixing REQUIREMENTS and CAPABILITIES.
>>>>
>>>> All deciders MUST Halt in finite time.
>>>
>>> And all deciders that simulate their infinitely repeating input are
>>> not allowed to ever stop.
>>>
>>> If they recognize an infinitely repeating pattern in N steps of
>>> simulation they are not allowed to report this otherwise the
>>> simulation is not accurate.
>>>
>>>
>>
>> No, if they can CORRECTLY prove that their input will NEVER halt
>> (even if they abort their simulation of them and go to Qn) then they
>> can do so, because they have an actual PROOF.
>>
>> You 'N Step' rule is bogus. Yes, you MIGHT be able, for SOME machines
>> detect a pattern in N Steps, but that doesn't work for all.
>>
>> The problem you have is that you can't prove that for H^, because it
>> isn't true. Your only proof is that as long as H doesn't abort, the
>> machine is non-halting.
>>
>> And that isn't even important, as there is no promise that a given
>> technique could work at all. Yes, we can see that SOME patterns are
>> clearly detectable, and thus abortable, but those just don't appear
>> in the simulation of H^ applied to <H^>.
>
> FOR FUCK'S SAKE CAN YOU TWO PACK IT IN ALREADY?
>
> /Flibble
>

This is my legacy before I die of cancer.

--
Copyright 2021 Pete Olcott

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