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.
>
> André
>

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.
>

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.
>
> 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
> final state had it not been aborted by some higher instance of
> embedded_H) or *no* instance of embedded_H can abort its input.
>
> You only actually get infinitely recursive simulation in the latter
> case. In the former case the chain is aborted and therefore not
> infinite.

THIS IS VERIFIED AS TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS WORDS:
When-so-ever any simulating halt decider detects its 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.

> 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.
>
> 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.
>
> 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

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?
>
>>> (and what humans can do with information x, y, and z tells us even
>>> left about what an algorithm can do with only x and y).
>>>
>>> If you want to claim it is possible for an algorithm to recognize
>>> infinitely recursive simulation, you need to actually show how that
>>> algorithm works.
>>>
>>
>> The first step of this elaboration requires acknowledgement that:
>> If humans can do thing X then thing X is proven to be possible to do.
>> ∴ if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn then embedded_H is correct.
>
> I can't possibly acknowledge anything about embedded_H if you won't
> provide the details of how it works such as the one I ask about above.
>
> André
>

It is stipulated that the key aspect of simulating halt deciders is that
they examine the behavior patterns of their simulated input.

It is universally true that when-so-ever a simulating halt decider must
abort the simulation of its input to prevent the infinite simulation of
this input that thus input specifies an infinite sequence of
configurations.

On the basis of the above it is self evident that the pure simulation of
⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never stop running, thus infinite behavior
is proved. Because infinite behavior is proved then a transition to Ĥ.qn
is proved to be correct.

The above by itself is much further than anyone has ever gotten with the
halting problem.

Because humans can easily see that ⟨Ĥ⟩ ⟨Ĥ⟩ specifies an infinite
sequence of configurations to simulating halt decider embedded_H it is
reasonable to conclude that a computation could do likewise.

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

On 3/1/2022 11:46 AM, André G. Isaak wrote:
> On 2022-03-01 08:50, 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?
>>>
>>>>> (and what humans can do with information x, y, and z tells us even
>>>>> left about what an algorithm can do with only x and y).
>>>>>
>>>>> If you want to claim it is possible for an algorithm to recognize
>>>>> infinitely recursive simulation, you need to actually show how that
>>>>> algorithm works.
>>>>>
>>>>
>>>> The first step of this elaboration requires acknowledgement that:
>>>> If humans can do thing X then thing X is proven to be possible to do.
>>>> ∴ if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn then embedded_H is correct.
>>>
>>> I can't possibly acknowledge anything about embedded_H if you won't
>>> provide the details of how it works such as the one I ask about above.
>>>
>>> André
>>>
>>
>> It is stipulated that the key aspect of simulating halt deciders is
>> that they examine the behavior patterns of their simulated input.
>
> "Stipulating" this doesn't magically make it possible.

In this case it does. You did not pay perfect attention to the exact
words that I used.

>> It is universally true that when-so-ever a simulating halt decider
>> must abort the simulation of its input to prevent the infinite
>> simulation of this input that thus input specifies an infinite
>> sequence of configurations.
>>
>> On the basis of the above it is self evident that the pure simulation
>> of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never stop running, thus infinite
>> behavior is proved. Because infinite behavior is proved then a
>> transition to Ĥ.qn is proved to be correct.
>>
>> The above by itself is much further than anyone has ever gotten with
>> the halting problem.
>>
>> Because humans can easily see that ⟨Ĥ⟩ ⟨Ĥ⟩ specifies an infinite
>> sequence of configurations to simulating halt decider embedded_H it is
>> reasonable to conclude that a computation could do likewise.
>
> That's not a proof. What a human can do tells us nothing about what is
> possible for an algorithm. And remember that the human has knowledge
> which the Turing Machine does not.
>

I have a computer program that can do this too, yet it is simply ruled
as not counting on the basis that it does not conform to the limitations
of computable functions.

> So how exactly does is the Turing Machine Ĥ determine whether its input
> string is a representation of itself?

A RASP machine simply sees that its input is at its same machine address.

> Unless it has some way of doing
> that, it has no way of recognizing that it is being called recursively.
>
> André
>

https://en.wikipedia.org/wiki/Random-access_stored-program_machine

If a RASP machine is strictly more powerful than a Turing machine then
simply abandon the TM model as inherently inferior.

--
Copyright 2021 Pete Olcott

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

On 3/1/2022 5:02 PM, André G. Isaak wrote:
> On 2022-03-01 13:59, olcott wrote:
>> On 3/1/2022 1:59 PM, André G. Isaak wrote:
>>> On 2022-03-01 11:32, olcott wrote:
>>>> On 3/1/2022 11:46 AM, André G. Isaak wrote:
>>>>> On 2022-03-01 08:50, 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?
>>>>>>>
>>>>>>>>> (and what humans can do with information x, y, and z tells us
>>>>>>>>> even left about what an algorithm can do with only x and y).
>>>>>>>>>
>>>>>>>>> If you want to claim it is possible for an algorithm to
>>>>>>>>> recognize infinitely recursive simulation, you need to actually
>>>>>>>>> show how that algorithm works.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The first step of this elaboration requires acknowledgement that:
>>>>>>>> If humans can do thing X then thing X is proven to be possible
>>>>>>>> to do.
>>>>>>>> ∴ if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn then embedded_H is correct.
>>>>>>>
>>>>>>> I can't possibly acknowledge anything about embedded_H if you
>>>>>>> won't provide the details of how it works such as the one I ask
>>>>>>> about above.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> It is stipulated that the key aspect of simulating halt deciders
>>>>>> is that they examine the behavior patterns of their simulated input.
>>>>>
>>>>> "Stipulating" this doesn't magically make it possible.
>>>>
>>>> In this case it does. You did not pay perfect attention to the exact
>>>> words that I used.
>>>>
>>>>>> It is universally true that when-so-ever a simulating halt decider
>>>>>> must abort the simulation of its input to prevent the infinite
>>>>>> simulation of this input that thus input specifies an infinite
>>>>>> sequence of configurations.
>>>>>>
>>>>>> On the basis of the above it is self evident that the pure
>>>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never stop running, thus
>>>>>> infinite behavior is proved. Because infinite behavior is proved
>>>>>> then a transition to Ĥ.qn is proved to be correct.
>>>>>>
>>>>>> The above by itself is much further than anyone has ever gotten
>>>>>> with the halting problem.
>>>>>>
>>>>>> Because humans can easily see that ⟨Ĥ⟩ ⟨Ĥ⟩ specifies an infinite
>>>>>> sequence of configurations to simulating halt decider embedded_H
>>>>>> it is reasonable to conclude that a computation could do likewise.
>>>>>
>>>>> That's not a proof. What a human can do tells us nothing about what
>>>>> is possible for an algorithm. And remember that the human has
>>>>> knowledge which the Turing Machine does not.
>>>>>
>>>>
>>>> I have a computer program that can do this too, yet it is simply
>>>> ruled as not counting on the basis that it does not conform to the
>>>> limitations of computable functions.
>>>>
>>>>> So how exactly does is the Turing Machine Ĥ determine whether its
>>>>> input string is a representation of itself?
>>>>
>>>> A RASP machine simply sees that its input is at its same machine
>>>> address.
>>>>
>>>>> Unless it has some way of doing that, it has no way of recognizing
>>>>> that it is being called recursively.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>>>
>>>> If a RASP machine is strictly more powerful than a Turing machine
>>>> then simply abandon the TM model as inherently inferior.
>>>
>>> You are horridly confused here.
>>>
>>> RASP machines or x86 machines are *not* more powerful than Turing
>>> Machines.
>>>
>>> Anything your computer can do is a computation. But it doesn't follow
>>> from that that any arbitrary C function or piece of x86 code is a
>>> computation, because a computation involves a *self-contained*
>>> algorithm.
>>>
>>> Thus, unless a C function or piece of x86 code can run *on its own*,
>>> it is not a computation. If it depends on other functions (including
>>> Operating System functions) then the *combination* of that function
>>> and all of the other functions it depends on can be construed as a
>>> computation, but the function on its own cannot be (and your computer
>>> wouldn't be able to run it in absence of those dependencies).
>>>
>>
>> Ah so a C function that has its own machine address directly encoded
>> into one of its x86 instructions is still a computation. This would be
>> the machine address of a label ---> __asm lea eax, HERE
>
> Sure, but it's a computation that has that address as part of its
> *input*. That means you're not dealing with the same computation as the
> halting problem.
>
> Again, when dealing with computations, 'input' doesn't just mean things
> which are passed to a function as formal parameters; it means *any* data
> which the function has access to and makes use of.
>
>>> The problem with all of your solutions to the halting problem isn't
>>> that they aren't computations, but that they are the *wrong*
>>> computation.
>>>
>>
>> So you assume by simply ignoring the self-evident truth of this
>> statement:
>> It is universally true that when-so-ever a simulating halt decider
>> must abort the simulation of its input to prevent the infinite
>> simulation of this input that thus input specifies an infinite
>> sequence of configurations.
>>
>>
>>> The input to a computation consists of *all* of the information which
>>> is made available to that computation, not just those bits of
>>> information which are passed as formal parameters to a C function.
>>>
>>> Given some C function defined as
>>>
>>
>> My C/x86 H merely needs to know its own machine address, then it can
>> tell that as soon as P calls H with identical parameters that this is
>> infinitely nested simulation.
>>
>>> Boolean foo(someType *X) {...}
>>>
>>> This function does not necessarily compute a function from X to a
>>> boolean value because a C function can in principle access all sorts
>>> of other data besides its formal parameter X. *Any* data which the
>>> function makes use of must be considered part of its input even if it
>>> isn't declared as a formal parameter.
>>>
>>> If a function refers to both some data in memory and the address of
>>> that data, those are two *separate* pieces of information, and when
>>> such a function is construed as a computation, both of those pieces
>>> of information must be treated as part of its input.
>>>
>>> The halting problem specifies exactly which information the input to
>>> a halt decider includes, and if a C function makes use of any data
>>> other than that information then the function may be a computation,
>>> but it is *not* the computation that the halting problem is concerned
>>> with.
>>
>> That seems like an arbitrary constraint.
>
> There's nothing arbitrary about it. When we ask whether W is computable
> from X and Y, and a program makes use of X, Y, and Z to calculate W then
> it isn't addressing the question being asked; it's addressing whether W
> is computable from X, Y, and Z, which is an entirely different question.
>

On 3/1/2022 1:59 PM, André G. Isaak wrote:
> On 2022-03-01 11:32, olcott wrote:
>> On 3/1/2022 11:46 AM, André G. Isaak wrote:
>>> On 2022-03-01 08:50, 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?
>>>>>
>>>>>>> (and what humans can do with information x, y, and z tells us
>>>>>>> even left about what an algorithm can do with only x and y).
>>>>>>>
>>>>>>> If you want to claim it is possible for an algorithm to recognize
>>>>>>> infinitely recursive simulation, you need to actually show how
>>>>>>> that algorithm works.
>>>>>>>
>>>>>>
>>>>>> The first step of this elaboration requires acknowledgement that:
>>>>>> If humans can do thing X then thing X is proven to be possible to do.
>>>>>> ∴ if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn then embedded_H is correct.
>>>>>
>>>>> I can't possibly acknowledge anything about embedded_H if you won't
>>>>> provide the details of how it works such as the one I ask about above.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> It is stipulated that the key aspect of simulating halt deciders is
>>>> that they examine the behavior patterns of their simulated input.
>>>
>>> "Stipulating" this doesn't magically make it possible.
>>
>> In this case it does. You did not pay perfect attention to the exact
>> words that I used.
>>
>>>> It is universally true that when-so-ever a simulating halt decider
>>>> must abort the simulation of its input to prevent the infinite
>>>> simulation of this input that thus input specifies an infinite
>>>> sequence of configurations.
>>>>
>>>> On the basis of the above it is self evident that the pure
>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never stop running, thus
>>>> infinite behavior is proved. Because infinite behavior is proved
>>>> then a transition to Ĥ.qn is proved to be correct.
>>>>
>>>> The above by itself is much further than anyone has ever gotten with
>>>> the halting problem.
>>>>
>>>> Because humans can easily see that ⟨Ĥ⟩ ⟨Ĥ⟩ specifies an infinite
>>>> sequence of configurations to simulating halt decider embedded_H it
>>>> is reasonable to conclude that a computation could do likewise.
>>>
>>> That's not a proof. What a human can do tells us nothing about what
>>> is possible for an algorithm. And remember that the human has
>>> knowledge which the Turing Machine does not.
>>>
>>
>> I have a computer program that can do this too, yet it is simply ruled
>> as not counting on the basis that it does not conform to the
>> limitations of computable functions.
>>
>>> So how exactly does is the Turing Machine Ĥ determine whether its
>>> input string is a representation of itself?
>>
>> A RASP machine simply sees that its input is at its same machine address.
>>
>>> Unless it has some way of doing that, it has no way of recognizing
>>> that it is being called recursively.
>>>
>>> André
>>>
>>
>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>
>> If a RASP machine is strictly more powerful than a Turing machine then
>> simply abandon the TM model as inherently inferior.
>
> You are horridly confused here.
>
> RASP machines or x86 machines are *not* more powerful than Turing Machines.
>
> Anything your computer can do is a computation. But it doesn't follow
> from that that any arbitrary C function or piece of x86 code is a
> computation, because a computation involves a *self-contained* algorithm.
>
> Thus, unless a C function or piece of x86 code can run *on its own*, it
> is not a computation. If it depends on other functions (including
> Operating System functions) then the *combination* of that function and
> all of the other functions it depends on can be construed as a
> computation, but the function on its own cannot be (and your computer
> wouldn't be able to run it in absence of those dependencies).
>
That is great I have a better understanding of this now.

Since H needs nothing outside of itself to determine its own machine
address H is still a computable function, even knowing it own machine
address.

In computer programming, a pure function is a function that has the
following properties:[1][2]

(1) the function return values are identical for identical arguments (no
variation with local static variables, non-local variables, mutable
reference arguments or input streams), and

(2) the function application has no side effects (no mutation of local
static variables, non-local variables, mutable reference arguments or
input/output streams).

https://en.wikipedia.org/wiki/Pure_function

Even though a C function would know its own machine address, it still
meets the requirements of (1) and (2) because it will always
consistently derive the same accept or reject state on the basis of the
same input and has no side effects.

If H is a computable function and a pure function that seems to be enough.

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

On 3/2/2022 6:09 AM, Richard Damon wrote:
> On 3/1/22 11:13 PM, olcott wrote:
>> On 3/1/2022 1:59 PM, André G. Isaak wrote:
>>> On 2022-03-01 11:32, olcott wrote:
>>>> On 3/1/2022 11:46 AM, André G. Isaak wrote:
>>>>> On 2022-03-01 08:50, 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?
>>>>>>>
>>>>>>>>> (and what humans can do with information x, y, and z tells us
>>>>>>>>> even left about what an algorithm can do with only x and y).
>>>>>>>>>
>>>>>>>>> If you want to claim it is possible for an algorithm to
>>>>>>>>> recognize infinitely recursive simulation, you need to actually
>>>>>>>>> show how that algorithm works.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The first step of this elaboration requires acknowledgement that:
>>>>>>>> If humans can do thing X then thing X is proven to be possible
>>>>>>>> to do.
>>>>>>>> ∴ if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn then embedded_H is correct.
>>>>>>>
>>>>>>> I can't possibly acknowledge anything about embedded_H if you
>>>>>>> won't provide the details of how it works such as the one I ask
>>>>>>> about above.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> It is stipulated that the key aspect of simulating halt deciders
>>>>>> is that they examine the behavior patterns of their simulated input.
>>>>>
>>>>> "Stipulating" this doesn't magically make it possible.
>>>>
>>>> In this case it does. You did not pay perfect attention to the exact
>>>> words that I used.
>>>>
>>>>>> It is universally true that when-so-ever a simulating halt decider
>>>>>> must abort the simulation of its input to prevent the infinite
>>>>>> simulation of this input that thus input specifies an infinite
>>>>>> sequence of configurations.
>>>>>>
>>>>>> On the basis of the above it is self evident that the pure
>>>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never stop running, thus
>>>>>> infinite behavior is proved. Because infinite behavior is proved
>>>>>> then a transition to Ĥ.qn is proved to be correct.
>>>>>>
>>>>>> The above by itself is much further than anyone has ever gotten
>>>>>> with the halting problem.
>>>>>>
>>>>>> Because humans can easily see that ⟨Ĥ⟩ ⟨Ĥ⟩ specifies an infinite
>>>>>> sequence of configurations to simulating halt decider embedded_H
>>>>>> it is reasonable to conclude that a computation could do likewise.
>>>>>
>>>>> That's not a proof. What a human can do tells us nothing about what
>>>>> is possible for an algorithm. And remember that the human has
>>>>> knowledge which the Turing Machine does not.
>>>>>
>>>>
>>>> I have a computer program that can do this too, yet it is simply
>>>> ruled as not counting on the basis that it does not conform to the
>>>> limitations of computable functions.
>>>>
>>>>> So how exactly does is the Turing Machine Ĥ determine whether its
>>>>> input string is a representation of itself?
>>>>
>>>> A RASP machine simply sees that its input is at its same machine
>>>> address.
>>>>
>>>>> Unless it has some way of doing that, it has no way of recognizing
>>>>> that it is being called recursively.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>>>
>>>> If a RASP machine is strictly more powerful than a Turing machine
>>>> then simply abandon the TM model as inherently inferior.
>>>
>>> You are horridly confused here.
>>>
>>> RASP machines or x86 machines are *not* more powerful than Turing
>>> Machines.
>>>
>>> Anything your computer can do is a computation. But it doesn't follow
>>> from that that any arbitrary C function or piece of x86 code is a
>>> computation, because a computation involves a *self-contained*
>>> algorithm.
>>>
>>> Thus, unless a C function or piece of x86 code can run *on its own*,
>>> it is not a computation. If it depends on other functions (including
>>> Operating System functions) then the *combination* of that function
>>> and all of the other functions it depends on can be construed as a
>>> computation, but the function on its own cannot be (and your computer
>>> wouldn't be able to run it in absence of those dependencies).
>>>
>> That is great I have a better understanding of this now.
>>
>> Since H needs nothing outside of itself to determine its own machine
>> address H is still a computable function, even knowing it own machine
>> address.
>
> If the behavior of a function changes based on where it is loaded into
> memory, then its loading address is an input to the function.
>

It merely needs to know where it is loaded so that it can see when it is
called.

> A Halt Decider doesn't get that as an input, so if it gets its address,
> and uses it to change its behavior, it isn't being the needed computation.
>

The requirement of a pure function is that the:
"the function return values are identical for identical arguments"
as long as there is no variation of this when it uses
local static variables, non-local variables, mutable reference arguments
or input streams. FIND AN ORIGINAL SOURCE THAT SAYS OTHERWISE

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. (and what humans can do with information
> x, y, and z tells us even left about what an algorithm can do with only
> x and y).
>
> If you want to claim it is possible for an algorithm to recognize
> infinitely recursive simulation, you need to actually show how that
> algorithm works.
>
> How does embedded_H determine whether its input leads to recursion or
> not? IOW, how does it recognize whether the input string includes a copy
> of itself?
>
> André
>

It would have to have some reference to its own machine description.
In the C/x86 version of these things the machine and its description are
one-and-the-same thing. The currently executing halt decider can derive
its own machine address. It can use this address for a string comparison.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

If embedded_H can compare the machine description of itself and its
inputs to its simulated call of a copy of this machine description at
Ĥ.qx then it can correctly reject ⟨Ĥ⟩ ⟨Ĥ⟩ as specifying infinitely
nested simulation. It can do this the first time that the simulated
embedded_H is called.

--
Copyright 2021 Pete Olcott

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

On 3/2/2022 10:21 AM, André G. Isaak wrote:
> On 2022-03-02 09:05, 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. (and what humans can do with
>>> information x, y, and z tells us even left about what an algorithm
>>> can do with only x and y).
>>>
>>> If you want to claim it is possible for an algorithm to recognize
>>> infinitely recursive simulation, you need to actually show how that
>>> algorithm works.
>>>
>>> How does embedded_H determine whether its input leads to recursion or
>>> not? IOW, how does it recognize whether the input string includes a
>>> copy of itself?
>>>
>>> André
>>>
>>
>> It would have to have some reference to its own machine description.
>
> But TMs do NOT have access to their own machine description. They have
> access only to what is placed on the tape as their input.
>

So we switch to RASP machines.

>> In the C/x86 version of these things the machine and its description
>> are one-and-the-same thing. The currently executing halt decider can
>> derive its own machine address. It can use this address for a string
>> comparison.
>
> And your C 'solution' is a cheat. Even if it did get the right answer
> (it doesn't) it isn't following the Linz proof nor does it implement the
> correct structure for a halt decider.
>

YOU KNOW THIS IS TRUE:
It is a fact that in both the C/x86 H/P and the Linz embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
that the simulating halt decider must abort the simulation of its input
or this simulation would never stop running.

THIS IS TRUE WHETHER YOU ACKNOWLEDGE IT OR NOT:
It is equally a fact (whether you comprehend this or not) that whenever
the simulated input to any simulating halt decider would never stop
running unless its was aborted that this input specifies infinite
execution.

These two things combined (even in isolation) represent a big
breakthrough in the halting problem.

> A halt decider is a COMPLETE and INDEPENDENT program which takes as its
> input a description of a COMPLETE and INDEPENDENT program which it then
> evaluates. If your P calls your H then your P is NOT a complete and
> independent program.
>
> Both P and H *must* be able to run independently in absence of the
> other. That means P must contain its own private copy of any code from H
> which it makes use of. Which means the embedded H inside P will *not*
> have the same address as H.
>

embedded_H will have the same address as embedded_H, and that it all
that I need.

>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>
> iff Ĥ applied to ⟨Ĥ⟩ halts.
>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> iff Ĥ applied to ⟨Ĥ⟩ does not halt.
>
> If you omit these conditions then what you write is meaningless.
>
>> If embedded_H can compare the machine description of itself and its
>> inputs
>
> Which it cannot do since it is not given a description of itself as an
> input.
>
> Also, while every TM description maps to a unique TM, there is no unique
> description for any TM. Each TM has infinitely many possible
> descriptions so just comparing two strings wouldn't cut it.
>

If it is a given that they have identical descriptions (as Linz
specifies) then this is not an issue. When I have refuted Linz I have
refuted the essence of the conventional halting problem proofs.

> André
>
>> to its simulated call of a copy of this machine description at Ĥ.qx
>> then it can correctly reject ⟨Ĥ⟩ ⟨Ĥ⟩ as specifying infinitely nested
>> simulation. It can do this the first time that the simulated
>> embedded_H is called.

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

On 3/2/2022 7:11 PM, Richard Damon wrote:
> On 3/2/22 11:57 AM, olcott wrote:
>> On 3/2/2022 10:21 AM, André G. Isaak wrote:
>>> On 2022-03-02 09:05, 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. (and what humans can
>>>>> do with information x, y, and z tells us even left about what an
>>>>> algorithm can do with only x and y).
>>>>>
>>>>> If you want to claim it is possible for an algorithm to recognize
>>>>> infinitely recursive simulation, you need to actually show how that
>>>>> algorithm works.
>>>>>
>>>>> How does embedded_H determine whether its input leads to recursion
>>>>> or not? IOW, how does it recognize whether the input string
>>>>> includes a copy of itself?
>>>>>
>>>>> André
>>>>>
>>>>
>>>> It would have to have some reference to its own machine description.
>>>
>>> But TMs do NOT have access to their own machine description. They
>>> have access only to what is placed on the tape as their input.
>>>
>>
>> So we switch to RASP machines.
>>
>>>> In the C/x86 version of these things the machine and its description
>>>> are one-and-the-same thing. The currently executing halt decider can
>>>> derive its own machine address. It can use this address for a string
>>>> comparison.
>>>
>>> And your C 'solution' is a cheat. Even if it did get the right answer
>>> (it doesn't) it isn't following the Linz proof nor does it implement
>>> the correct structure for a halt decider.
>>>
>>
>> YOU KNOW THIS IS TRUE:
>> It is a fact that in both the C/x86 H/P and the Linz embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>> that the simulating halt decider must abort the simulation of its
>> input or this simulation would never stop running.
>
> Yes, that means that if H is Hn that doesn't abort
The key thing that it means is that the halt decider is necessarily
correct when it rejects its input.

It is over your head and you simply lack the necessary intellectual
capacity to ever get it.

--
Copyright 2021 Pete Olcott

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

On 3/2/2022 8:16 PM, Richard Damon wrote:
>
> On 3/2/22 8:24 PM, olcott wrote:
>> On 3/2/2022 7:11 PM, Richard Damon wrote:
>>> On 3/2/22 11:57 AM, olcott wrote:
>>>> On 3/2/2022 10:21 AM, André G. Isaak wrote:
>>>>> On 2022-03-02 09:05, 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. (and what humans
>>>>>>> can do with information x, y, and z tells us even left about what
>>>>>>> an algorithm can do with only x and y).
>>>>>>>
>>>>>>> If you want to claim it is possible for an algorithm to recognize
>>>>>>> infinitely recursive simulation, you need to actually show how
>>>>>>> that algorithm works.
>>>>>>>
>>>>>>> How does embedded_H determine whether its input leads to
>>>>>>> recursion or not? IOW, how does it recognize whether the input
>>>>>>> string includes a copy of itself?
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> It would have to have some reference to its own machine description.
>>>>>
>>>>> But TMs do NOT have access to their own machine description. They
>>>>> have access only to what is placed on the tape as their input.
>>>>>
>>>>
>>>> So we switch to RASP machines.
>>>>
>>>>>> In the C/x86 version of these things the machine and its
>>>>>> description are one-and-the-same thing. The currently executing
>>>>>> halt decider can derive its own machine address. It can use this
>>>>>> address for a string comparison.
>>>>>
>>>>> And your C 'solution' is a cheat. Even if it did get the right
>>>>> answer (it doesn't) it isn't following the Linz proof nor does it
>>>>> implement the correct structure for a halt decider.
>>>>>
>>>>
>>>> YOU KNOW THIS IS TRUE:
>>>> It is a fact that in both the C/x86 H/P and the Linz embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> that the simulating halt decider must abort the simulation of its
>>>> input or this simulation would never stop running.
>>>
>>> Yes, that means that if H is Hn that doesn't abort
>> The key thing that it means is that the halt decider is necessarily
>> correct when it rejects its input.
>
>
> So a Halt Decider that rejects everything is correct that NO
> computations halt?

The fact that H(P,P) and embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ both must abort the
simulation of their input conclusively proves they are correct in
rejecting this input. NITWIT

--
Copyright 2021 Pete Olcott

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

On 3/2/2022 8:40 PM, Richard Damon wrote:
> On 3/2/22 9:28 PM, olcott wrote:
>> On 3/2/2022 8:16 PM, Richard Damon wrote:
>>>
>>> On 3/2/22 8:24 PM, olcott wrote:
>>>> On 3/2/2022 7:11 PM, Richard Damon wrote:
>>>>> On 3/2/22 11:57 AM, olcott wrote:
>>>>>> On 3/2/2022 10:21 AM, André G. Isaak wrote:
>>>>>>> On 2022-03-02 09:05, 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. (and what humans
>>>>>>>>> can do with information x, y, and z tells us even left about
>>>>>>>>> what an algorithm can do with only x and y).
>>>>>>>>>
>>>>>>>>> If you want to claim it is possible for an algorithm to
>>>>>>>>> recognize infinitely recursive simulation, you need to actually
>>>>>>>>> show how that algorithm works.
>>>>>>>>>
>>>>>>>>> How does embedded_H determine whether its input leads to
>>>>>>>>> recursion or not? IOW, how does it recognize whether the input
>>>>>>>>> string includes a copy of itself?
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> It would have to have some reference to its own machine
>>>>>>>> description.
>>>>>>>
>>>>>>> But TMs do NOT have access to their own machine description. They
>>>>>>> have access only to what is placed on the tape as their input.
>>>>>>>
>>>>>>
>>>>>> So we switch to RASP machines.
>>>>>>
>>>>>>>> In the C/x86 version of these things the machine and its
>>>>>>>> description are one-and-the-same thing. The currently executing
>>>>>>>> halt decider can derive its own machine address. It can use this
>>>>>>>> address for a string comparison.
>>>>>>>
>>>>>>> And your C 'solution' is a cheat. Even if it did get the right
>>>>>>> answer (it doesn't) it isn't following the Linz proof nor does it
>>>>>>> implement the correct structure for a halt decider.
>>>>>>>
>>>>>>
>>>>>> YOU KNOW THIS IS TRUE:
>>>>>> It is a fact that in both the C/x86 H/P and the Linz embedded_H
>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> that the simulating halt decider must abort the simulation of its
>>>>>> input or this simulation would never stop running.
>>>>>
>>>>> Yes, that means that if H is Hn that doesn't abort
>>>> The key thing that it means is that the halt decider is necessarily
>>>> correct when it rejects its input.
>>>
>>>
>>> So a Halt Decider that rejects everything is correct that NO
>>> computations halt?
>>
>> The fact that H(P,P) and embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ both must abort the
>> simulation of their input conclusively proves they are correct in
>> rejecting this input. NITWIT
>>
>
> NOPE. Source for that?
>
> Yes, you can show that Hn^ applied to <Hn^> is non-halting if it is
> built on the Hn that doesn't abort, but when you change you H to be the
> Ha that does abort, you haven't proved that Ha^ applied to <Ha^> doesn't
> halt, only that Ha would be correct if it was applied to <Hn^> <Hn^> but
> that isn't the Linz computaiton.
>

As long as embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its input to prevent its
infinite simulation then this is complete proof the embedded_H is
correct to reject this input.

My paper is about the infinite set of simulating halt deciders applied
to each element of the set of Turing machine descriptions.

When-so-ever shd ∈ simulating_halt_deciders simulates tmd ∈
Turing_machine_descriptions would never stop unless aborted then
shd.rejects(tmd)

If the above is always true then it is true for embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩

> You make the error of conflating your two machines, because you have a
> fabled machine that is two different machines at once, your Fairy Dust
> Powered Unicorn.
>
> H must be EITHER Hn that doens't abort or the Ha that does, it doesn't
> magically change in the middle of the problem from one to the other.
>
> FAIL.
>

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

On 3/1/2022 11:46 AM, André G. Isaak wrote:
> On 2022-03-01 08:50, 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?
>>>
>>>>> (and what humans can do with information x, y, and z tells us even
>>>>> left about what an algorithm can do with only x and y).
>>>>>
>>>>> If you want to claim it is possible for an algorithm to recognize
>>>>> infinitely recursive simulation, you need to actually show how that
>>>>> algorithm works.
>>>>>
>>>>
>>>> The first step of this elaboration requires acknowledgement that:
>>>> If humans can do thing X then thing X is proven to be possible to do.
>>>> ∴ if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn then embedded_H is correct.
>>>
>>> I can't possibly acknowledge anything about embedded_H if you won't
>>> provide the details of how it works such as the one I ask about above.
>>>
>>> André
>>>
>>
>> It is stipulated that the key aspect of simulating halt deciders is
>> that they examine the behavior patterns of their simulated input.
>
> "Stipulating" this doesn't magically make it possible.
>
>> It is universally true that when-so-ever a simulating halt decider
>> must abort the simulation of its input to prevent the infinite
>> simulation of this input that thus input specifies an infinite
>> sequence of configurations.
>>
>> On the basis of the above it is self evident that the pure simulation
>> of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never stop running, thus infinite
>> behavior is proved. Because infinite behavior is proved then a
>> transition to Ĥ.qn is proved to be correct.
>>
>> The above by itself is much further than anyone has ever gotten with
>> the halting problem.
>>
>> Because humans can easily see that ⟨Ĥ⟩ ⟨Ĥ⟩ specifies an infinite
>> sequence of configurations to simulating halt decider embedded_H it is
>> reasonable to conclude that a computation could do likewise.
>
> That's not a proof. What a human can do tells us nothing about what is
> possible for an algorithm. And remember that the human has knowledge
> which the Turing Machine does not.
>
> So how exactly does is the Turing Machine Ĥ determine whether its input
> string is a representation of itself? Unless it has some way of doing
> that, it has no way of recognizing that it is being called recursively.
>
> André
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

NON-HALTING CRITERION MEASURE
It is universally true that when-so-ever a simulating halt decider must
abort the simulation of its input to prevent the infinite simulation of
this input that this input specifies an infinite sequence of
configurations.

On the basis of the above it is self evident that the pure simulation of
⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never stop running, thus infinite behavior
is proved. Because infinite behavior is proved then a transition to Ĥ.qn
is proved to be correct.

Because all simulating halt deciders are deciders they ONLY compute the
mapping from their inputs to an accept or reject state. This means that
embedded_H does not determine the halt status of itself or the
computation that contains it: Ĥ ⟨Ĥ⟩ because these are not inputs.

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