On 1/15/2022 9:54 AM, Richard Damon wrote:
> On 1/15/22 9:33 AM, olcott wrote:
>> On 1/15/2022 5:06 AM, Richard Damon wrote:
>>> On 1/14/22 11:51 PM, olcott wrote:
>>>> On 1/14/2022 10:34 PM, Richard Damon wrote:
>>>>> On 1/14/22 11:26 PM, olcott wrote:
>>>>>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>>>>>> On 1/14/22 10:44 PM, olcott wrote:
>>>>>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is the case that the copy of H (called embedded_H) at
>>>>>>>>>>>>>>>> Ĥ.qx must abort
>>>>>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A simulating halt decider simulates N steps of its input
>>>>>>>>>>>>>>>> until its input
>>>>>>>>>>>>>>>> halts on its own or it correctly determines that a pure
>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal Languages
>>>>>>>>>>>>>>>> and Automata.
>>>>>>>>>>>>>>>> Lexington/Toronto: D. C. Heath and Company. (315-320)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A Turing machine applied to some input reaches one final
>>>>>>>>>>>>>>> state or one infinite loop, not two different ones. This
>>>>>>>>>>>>>>> is a consequence of the definition of determinism.
>>>>>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at Ĥ.qx
>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis that a
>>>>>>>>>>>>>> mathematical
>>>>>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is proven
>>>>>>>>>>>>>> on the basis
>>>>>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested
>>>>>>>>>>>>>> simulation to the
>>>>>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>>>>>> --
>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>>>>>> is a question. A question that has only one answer. We can
>>>>>>>>>>>>> find the answer by passing the arguments ⟨Ĥ.q0⟩ and ⟨Ĥ⟩ to
>>>>>>>>>>>>> a UTM. Otherwise it is like saying:
>>>>>>>>>>>>>
>>>>>>>>>>>>> 2+2 = 4
>>>>>>>>>>>>> 2+2 = 5
>>>>>>>>>>>>
>>>>>>>>>>>> That is not the question and you know it.
>>>>>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>>>>>
>>>>>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except it isn't
>>>>>>>>>>>
>>>>>>>>>>> The DEFINITION of a correct H was
>>>>>>>>>>>
>>>>>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it does)
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>> Ĥ.qy or Ĥ.qn based on the actual behavior specified by its
>>>>>>>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>> Do you understand that this is correct, or do you not know
>>>>>>>>>> computer science well enough to understand that this is correct?
>>>>>>>>>
>>>>>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as H^
>>>>>>>>> applied to <H^> (BY DEFINITION) which goes to H^.Qn and Halts
>>>>>>>>> if the copy of H in it goes to H.Qn, which it does if H mapped
>>>>>>>>> <H^> <H^> to H.Qn which you claim, so the behavior specified by
>>>>>>>>> the input is HALTING.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I won't count that as wrong because the part that you got wrong
>>>>>>>> was outside the scope of the original question.
>>>>>>>>
>>>>>>>> You 100% agree with this:
>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> The next step after we agree on that point is:
>>>>>>>> How we measure the actual behavior of the input to embedded_H:
>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>>>>>>>
>>>>>>>  From the definition of the problem: it is defined as the
>>>>>>> behavior of H^ applied to <H^> or its equivalent of
>>>>>>> UTM(<H^>,<H^>) and nothing else.
>>>>>> Ah so you don't understand enough computer science to know that
>>>>>> every decider implements a computable function that maps its
>>>>>> input(s) to an accept reject state.
>>>>>>
>>>>>> Unless you understand this we cannot proceed. It makes sense that
>>>>>> I apply this same threshold of understanding to all of my reviewers.
>>>>>>
>>>>>
>>>>> No, I understand that perfectly, H needs to compute a mapping from
>>>>> its inputs, but the definition of the mapping, in this case is the
>>>>> Halting Function, which it turns out is NOT directly computatable
>>>>> from the inputs.
>>>>>
>>>>
>>>> Because you tend to weasel word all over the place and have your
>>>> rebuttal ignore what I am currently saying and instead refer to
>>>> something that I said 50 posts ago let's be perfectly clear:
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>>
>>> So, no answer?
>>>
>>
>> I am asking whether or not you agree with the above,
>> Linz says it in a less precise way that can be misinterpreted.
>>
>> Unless and until you understand enough computer science to
>> know that the way that I said it is correct we cannot proceed.
>>
>> DO YOU PERFECTLY AGREE THAT THIS IS 100% CORRECT?
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> That is a NONSENSE statement without the conditions on it.
>>
>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>
> Right.
>
> AND the input <H^> <H^> is a description of the whole computation being
> preformed.
>
> Note, this puts H in a bind,

There is no H, there is only a copy of H at Ĥ.qx that is referred to as
embedded_H.

> if its algorithm decides that this input
> should take it to the Qn state, then the actual behavior of the
> computatiion this input represents will be HALTING

There is no "represents", there is only the actual behavior specified by
the actual input to embedded_H: ⟨Ĥ⟩ ⟨Ĥ⟩.

embedded_H computes the mapping from its input: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn.

The actual behavior of this actual input is measured by the pure
simulation of N steps by embedded_H of its input ⟨Ĥ⟩ applied to ⟨Ĥ⟩.

--
Copyright 2021 Pete Olcott

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