On 1/2/22 3:20 PM, olcott wrote:
> On 1/2/2022 2:01 PM, Richard Damon wrote:
>> On 1/2/22 2:45 PM, olcott wrote:
>>> On 1/2/2022 1:38 PM, Richard Damon wrote:
>>>> On 1/2/22 2:19 PM, olcott wrote:
>>>>> On 1/2/2022 12:29 PM, Richard Damon wrote:
>>>>>> On 1/2/22 1:13 PM, olcott wrote:
>>>>>>> On 1/2/2022 11:52 AM, Richard Damon wrote:
>>>>>>>> On 1/2/22 11:07 AM, olcott wrote:
>>>>>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-12-31 17:05, olcott wrote:
>>>>>>>>>>>>> On 12/31/2021 5:33 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-12-31 16:02, olcott wrote:
>>>>>>>>>>>>>>> On 12/31/2021 4:06 PM, André G. Isaak wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> An actual computer scientist will understand that
>>>>>>>>>>>>>>> embedded_H does compute the mapping from these inputs
>>>>>>>>>>>>>>> finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this final state Ĥ.qn on the
>>>>>>>>>>>>>>> basis that the actual input would never halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You're not really in a position to state what an actual
>>>>>>>>>>>>>> computer scientist would understand. Only an actual
>>>>>>>>>>>>>> computer scientist can do that.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is a self-evident truth that:
>>>>>>>>>>>>> (a) The pure simulation of the Turing machine description
>>>>>>>>>>>>> of a machine is computationally equivalent to the direct
>>>>>>>>>>>>> execution of this machine.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (b) The pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>> never halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (c) If the pure simulation of the input to a halt decider
>>>>>>>>>>>>> would never halt then the halt decider correctly decides
>>>>>>>>>>>>> that this input does not halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A computer scientist would understand these things.
>>>>>>>>>>>>
>>>>>>>>>>>> It would appear that you ignored (and cut) all the actual
>>>>>>>>>>>> points in my post.
>>>>>>>>>>>>
>>>>>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called,
>>>>>>>>>>>> how does Ĥ determine that its input describes itself? You
>>>>>>>>>>>> claim this is done by string comparisons, but which strings
>>>>>>>>>>>> are being compared? The only string Ĥ has access to its
>>>>>>>>>>>> input string. What does it compare this string with?
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So far I have not gotten to any point of closure on anything
>>>>>>>>>>> that I have said. I must insist on points of closure for
>>>>>>>>>>> continued dialogue.
>>>>>>>>>>>
>>>>>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>> embedded_H would never halt?
>>>>>>>>>>
>>>>>>>>>> Of course I don't, since that claim is simply false.
>>>>>>>>>>
>>>>>>>>>> Now why don't you actually answer the question I asked?
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>> embedded_H.
>>>>>>>>>
>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> this input would never reach a final state and stop running.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, so Hn generates an H^n that never halts when computing
>>>>>>>> Hn^ <Hn^>
>>>>>>>>
>>>>>>>> But Hn <Hn^> <Hn^> doesn't answer, so it doesn't get the right
>>>>>>>> answer.
>>>>>>>>
>>>>>>>
>>>>>>> If the simulation of the input would never reach its final state
>>>>>>> if embedded_H would never stop its simulation then embedded_H can
>>>>>>> stop its simulation at any point and report that its input meets
>>>>>>> the Linz definition of not halting.
>>>>>>
>>>>>> No, it can't, because you made a change to the code in H^ when you
>>>>>> did that, thus invalidating your previous determination.
>>>>>>
>>>>>
>>>>> Not at all. The code remains the same. In the same way that a halt
>>>>> decider need not actually eternally simulate an infinite loop to
>>>>> determine that this simulation would never reach any final state
>>>>> the halt decider determines that infinitely nested simulations
>>>>> would never reach their final state.
>>>>
>>>> Impossible. Please prove this assertion.
>>>>
>>>
>>> An algorithm can correctly predict the future behavior of a computation.
>>
>> No, it can't, at least not universally correctly.
>>
>> It is PROVEN that some programs can not be predicted without running
>> them to their end, and that might take an infinite number of steps.
>>
>
> Simplified syntax adapted from bottom of page 319:
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
> this input would never reach a final state and stop running.
>
> These steps would keep repeating:
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>
> Since it is obvious that the pure simulation of the input to embedded_H
> never reaches its final state then it is obvious that when embedded_H
> transitions to Ĥ.qn it is correct.

But if embedded_H never stops its simulation, it can never actually GO
to H.qn.

If embedded_H was able to abort its simulation, then it never was the
UTM needed to be the arbiter of Halting, that is reserved for a real UTM.

The problem is that you are applying the wrong logic to the problem.

You are imagining TWO DIFFERENT Hs which lead to TWO DIFFERENT H^s, the
behavior of one does not imply the same behavior of the other. This is
why your logic is UNSOUND.

Instead, you need to imagine what would happen if JUST the top H was
replaced with a UTM, but the input keeps its exact same coding which has
the original H encoded in it. If this never halts, and H answered
non-halting, then H was right, or it it halts and H answered Halting,
then H was also right. The problem is that if H answer Non-Halting, then
H^ will Halt, so H is WRONG.

The test is the test specified by the DEFINITION of the Halt Decider:

H wM w -> Qy iff M w Halts and H wM w -> Qn iff M w Never Halts.
which is equivalent to:

H wM w -> Qy iff UTM wM w Halts and H wM w -> Qn iff UTM wM w Never Halts.

Note, it doesn't say change any copys of H that happen to be in the
representation of M or w, only apply the input EXACTLY as given to H to
the UTM and see what it does. This is also ONLY a TEST of the behavior,
since H needs to give its answer in finite time and UTM the UTM never
stops for the Non-Halting case, you can't just use a UTM for the actual
decider.

I have also show you the proof that there is no finite list of finite
patterns that H can use to decide to abort a UTM like simulation to make
the decision.

FAIL.