On 2/26/2022 3:02 PM, André G. Isaak wrote:
> On 2022-02-26 13:38, olcott wrote:
>> On 2/26/2022 1:23 PM, André G. Isaak wrote:
>>> On 2022-02-26 08:08, olcott wrote:
>>>> On 2/26/2022 12:05 AM, André G. Isaak wrote:
>>>>> On 2022-02-25 15:28, olcott wrote:
>>>>>> On 2/25/2022 3:19 PM, André G. Isaak wrote:
>>>>>>> On 2022-02-25 12:11, olcott wrote:
>>>>>>>> On 2/25/2022 1:00 PM, André G. Isaak wrote:
>>>>>>>>> On 2022-02-25 10:32, olcott wrote:
>>>>>>>>>> On 2/25/2022 11:17 AM, André G. Isaak wrote:
>>>>>>>>>>> On 2022-02-25 09:11, olcott wrote:
>>>>>>>>>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>>>>>>>>>> Simulating halt deciders continue to simulate their input
>>>>>>>>>>>>>> until they determine that this simulated input would never
>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But how do they determine that?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that humans can see that in both cases the
>>>>>>>>>>>> simulated input never reaches its final state in any finite
>>>>>>>>>>>> number of simulated steps conclusively proves that it is
>>>>>>>>>>>> possible to correctly detect the infinite loop and the
>>>>>>>>>>>> infinitely nested simulation.
>>>>>>>>>>>
>>>>>>>>>>> What humans can do provides no evidence at all about what
>>>>>>>>>>> algorithms can do. Humans are not algorithms.
>>>>>>>>>>
>>>>>>>>>> If humans can do thing X then thing X is proven to be possible
>>>>>>>>>> to do.
>>>>>>>>>
>>>>>>>>> People can win olympic pole vaulting competitions. It doesn't
>>>>>>>>> follow from this that a Turing Machine can.
>>>>>>>>>
>>>>>>>>> And you, the human, are recognizing something making use of a
>>>>>>>>> piece of information with which the TM is *NOT* provided; you
>>>>>>>>> are aware of the fact that the input happens to be a
>>>>>>>>> representation of Ĥ, a machine which includes a copy of
>>>>>>>>> embedded_H.
>>>>>>>>>
>>>>>>>>> embedded_H, on the other hand, is *not* provided with this
>>>>>>>>> information.
>>>>>>>>>
>>>>>>>>> So how does your embedded_H recognize that the input string
>>>>>>>>> includes a copy of itself?
>>>>>>>>>
>>>>>>>>
>>>>>>>> I won't say that until after you acknowledge that embedded_H
>>>>>>>> would be correct to transition to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ because
>>>>>>>> it is the case that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>> embedded_H cannot possibly reach ⟨Ĥ⟩.qn.
>>>>>>>
>>>>>>>
>>>>>>> I can't acknowledge something with which I disagree.
>>>>>>>
>>>>>>> But the question I asked would require answering even if I agreed
>>>>>>> to the above. So if you were actually serious in your desire to
>>>>>>> convince people that your argument works you would answer this
>>>>>>> question regardless.
>>>>>>>
>>>>>>> That you refuse to do so would appear to indicate that you
>>>>>>> realize you have no idea how your embedded_H is supposed to
>>>>>>> recognize the pattern you claim it is able to recognize which
>>>>>>> throws your entire argument out the window.
>>>>>>
>>>>>> I am trying to find which points there is mutual agreement.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩
>>>>>> ⟨Ĥ2⟩
>>>>>>
>>>>>> Then these steps would keep repeating:
>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩
>>>>>> ⟨Ĥ3⟩
>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩
>>>>>> ⟨Ĥ4⟩
>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>>>> ⟨Ĥ5⟩...
>>>>>>
>>>>>> Do you agree that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>> could never reach the final state ⟨Ĥ⟩.qn ?
>>>>>
>>>>> I'm not clear why you are asking this since in the very post to
>>>>> which you are responding I clearly stated that I do *not* agree
>>>>> with this. Asking me again isn't going to generate a different answer.
>>>>>
>>>>
>>>> You implied that you agreed when you implied that a human could see
>>>> this. We can't move forward until we have mutual agreement on this
>>>> point.
>>>>
>>>> Can you as a human see that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>> embedded_H could never reach the final state ⟨Ĥ⟩.qn ?
>>>
>>> No. Because this claim is false. You need to actually get your
>>> indexing correct:
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>
>>> Then these steps would keep repeating:
>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H3 simulates ⟨Ĥ4⟩
>>> ⟨Ĥ5⟩...
>>>
>>> If embedded_H0 aborts its input and then transitions to ⟨Ĥ⟩.qn, then
>>> embedded_H1 would similarly abort its input and transition to ⟨Ĥ1⟩.qn
>>> had embedded_H0 not aborted it.
>>>
>>
>> That is like saying that dead men can easily walk across the street as
>> long as they are not dead, AKA double-talk.
>>
>>> Either *every* instance of embedded_H can abort its input in which
>>> case every instance of embedded_H reaches a final state (or would
>>> reach a
>>
>> Incorrect quantification. At most one instance of embedded_H can abort
>> the simulation of its input and this input never reaches its final
>> state whether or not it is ever aborted.
>>
>>> final state had it not been aborted by some higher instance of
>>> embedded_H) or *no* instance of embedded_H can abort its input.
>>>
>>
>> THIS IS VERIFIED AS TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS
>> WORDS:
>> When-so-ever any simulating halt decider detects that a correct and
>> complete pure simulation of its input would never reach the final
>> state of this simulated input it is correct to abort the simulation of
>> the input and transition to its own final reject state.
>>
>>> You only actually get infinitely recursive simulation in the latter
>>> case. In the former case the chain is aborted and therefore not
>>> infinite. but in the latter case your H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is also
>>> infinitely recursive and thus fails to qualify as a decider.
>>>
>>> But even if your argument didn't suffer from this problem, you'd
>>> still be left with the issue which you are refusing to address: You
>>> claim that a pattern of infinitely recursive simulation can be
>>> recognized by a Turing Machine, when in fact it cannot be.
>>>
>>
>> There is a mandatory hierarchy to reverse engineering the correct
>> solution to difficult problems using categorically exhaustive
>> reasoning (a specific instance of reasoning from first principles):
>>
>> (1) Is a correct solution possible?
>> (2) What are the steps to this correct solution?
>> You are trying to skip step (1).
>>
>> I have proven that a solution is possible in that I have proven that
>> the simulated input to embedded_H cannot possibly reach its final
>> state of ⟨Ĥ⟩.qn in any finite number of steps of pure simulation. We
>> cannot move on to (2) until after we have mutual agreement on (1).
>>
>>> The fact that a human can recognize such an infinite pattern from
>>> *outside* the system with the added knowledge that the input to the Ĥ
>>> is in fact a description of Ĥ in no way demonstrates that it would be
>>> possibly for Ĥ to do this when Ĥ has no knowledge of whether its
>>> input string is a representation of itself or not.
>>>
>>> So even if this pattern existed, how exactly is your embedded_H
>>> supposed to recognize it?
>>>
>>> I addressed your question, so please address mine.
>
> You seem to have missed the last bit.
>
> I'm not going to address any of your points until you make at least some
> effort to address mine.
>

Your question has my question as a mandatory prerequisite.
Before the detailed steps of a solution are reverse-engineered (your
question) we must first address the broader category is a solution
possible? (my question).

I have proved that a solution is possible and you keep ignoring this
proof. If you are going to reject my basis out-of-hand without review
then it makes no sense to extend this basis to the reasoning that
follows from it.

> How does a TM determine that its input string is a representation of
> itself?
>
> André
>
>

--
Copyright 2021 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer