On 1/2/2022 2:36 PM, Richard Damon wrote:
>
> 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.
>

I think at this point we can answer the key question: honest dialogue?
The answer is no. None of my reviewers want an honest dialogue.

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

--
Copyright 2021 Pete Olcott

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