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.

> These steps would keep repeating:
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>
> computation that halts
> ...the Turing machine will halt whenever it enters a final state
> (Linz:1990:234)
>
> That you disagree with self-evident truth proves that you do not want
> any honest dialogue.
>

So you think Decider that doesn't answer is correct?

Or are you confusing this with the fact that when you then change to Ha
that DOES abort, we have shown that since Ha <Ha^> <Ha^> -> H.qn, that
Ha^ <Ha^> also go to Ha^.qn, and thus halts so Ha was WRONG.

Your logic only shows that Ha <Hn^> <Hn^> gets the right answer, but
that doesn't matter, as that isn't the Linz case.

Or are you too stupid to understand that Ha^ and Hn^ are different
algorithms because Ha and Hn are different algroithms?

Or, are you just lying because that is the only way to make your point.

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.

>> These steps would keep repeating:
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>> computation that halts
>> ...the Turing machine will halt whenever it enters a final state
>> (Linz:1990:234)
>>
>> That you disagree with self-evident truth proves that you do not want
>> any honest dialogue.
>>
>
> So you think Decider that doesn't answer is correct?
>
> Or are you confusing this with the fact that when you then change to Ha
> that DOES abort, we have shown that since Ha <Ha^> <Ha^> -> H.qn, that
> Ha^ <Ha^> also go to Ha^.qn, and thus halts so Ha was WRONG.
>
>
> Your logic only shows that Ha <Hn^> <Hn^> gets the right answer, but
> that doesn't matter, as that isn't the Linz case.
>
> Or are you too stupid to understand that Ha^ and Hn^ are different
> algorithms because Ha and Hn are different algroithms?
>
> Or, are you just lying because that is the only way to make your point.
>

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

FAIL.

The test is NOT using Hypothetical alternatives to H, but putting the
actual input into a UTM.

The RIGHT test is, using the EXACT definition of H that you think is
correct, put that EXACT copy of the input into UTM.

When you do this CORRECT test, you find that if H decides that H^ is
non-halting and goes to H.qn, then H^ also goes to H^.qn and shows that
H was wrong.

PERIOD.

Either you are too stupid to understand this, suffer from some mental
condition that make you unable to understand this truth, or you are just
a pathological liar that needs to be 'right' by insisting on something
you know not to be true.

FAIL.

>
>>> These steps would keep repeating:
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>> computation that halts
>>> ...the Turing machine will halt whenever it enters a final state
>>> (Linz:1990:234)
>>>
>>> That you disagree with self-evident truth proves that you do not want
>>> any honest dialogue.
>>>
>>
>> So you think Decider that doesn't answer is correct?
>>
>> Or are you confusing this with the fact that when you then change to
>> Ha that DOES abort, we have shown that since Ha <Ha^> <Ha^> -> H.qn,
>> that Ha^ <Ha^> also go to Ha^.qn, and thus halts so Ha was WRONG.
>>
>>
>> Your logic only shows that Ha <Hn^> <Hn^> gets the right answer, but
>> that doesn't matter, as that isn't the Linz case.
>>
>> Or are you too stupid to understand that Ha^ and Hn^ are different
>> algorithms because Ha and Hn are different algroithms?
>>
>> Or, are you just lying because that is the only way to make your point.
>>
>
>

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.

If the infinite simulation WOULD NEVER HALT is not the same as DOES
NEVER STOP RUNNING.

Unless English is your second language your very persistent inability to
understand the difference between WOULD and DOES cannot be reasonably
construed as any honest mistake.

> FAIL.
>
> The test is NOT using Hypothetical alternatives to H, but putting the
> actual input into a UTM.
>
> The RIGHT test is, using the EXACT definition of H that you think is
> correct, put that EXACT copy of the input into UTM.
>
> When you do this CORRECT test, you find that if H decides that H^ is
> non-halting and goes to H.qn, then H^ also goes to H^.qn and shows that
> H was wrong.
>
> PERIOD.
>
> Either you are too stupid to understand this, suffer from some mental
> condition that make you unable to understand this truth, or you are just
> a pathological liar that needs to be 'right' by insisting on something
> you know not to be true.
>
> FAIL.
>
>>
>>>> These steps would keep repeating:
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>> computation that halts
>>>> ...the Turing machine will halt whenever it enters a final state
>>>> (Linz:1990:234)
>>>>
>>>> That you disagree with self-evident truth proves that you do not
>>>> want any honest dialogue.
>>>>
>>>
>>> So you think Decider that doesn't answer is correct?
>>>
>>> Or are you confusing this with the fact that when you then change to
>>> Ha that DOES abort, we have shown that since Ha <Ha^> <Ha^> -> H.qn,
>>> that Ha^ <Ha^> also go to Ha^.qn, and thus halts so Ha was WRONG.
>>>
>>>
>>> Your logic only shows that Ha <Hn^> <Hn^> gets the right answer, but
>>> that doesn't matter, as that isn't the Linz case.
>>>
>>> Or are you too stupid to understand that Ha^ and Hn^ are different
>>> algorithms because Ha and Hn are different algroithms?
>>>
>>> Or, are you just lying because that is the only way to make your point.
>>>
>>
>>
>

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

A given coded algorithm will ALWAYS behave the same given the same
input, so can't do both 'Never halt' and 'Abort and return an answer'.

If you 'imagine' the code behaving one way, you need to actually use
code that does that.

It seems that

>
> If the infinite simulation WOULD NEVER HALT is not the same as DOES
> NEVER STOP RUNNING.

For this definition it is, or needs to be.

Non-Halting is shown by a Machine (or UTM simulation of it) that WOULD
NEVER HALT IF ALLOWED TO RUN FOREVER.

We need to use WOULD, as we can't actually run forever.

Since the only machine that the definition as an ACTUAL UTM, the meaning
is the same.

Note, your partial simulator, which doesn't see halting unless it aborts
does NOT meet the requirement, because the way YOU look at it you are
changing the behavior of the machine in multiple places.

It is also the case the your partial simulator will either Abort its
simulation or Not, so imagining that it doesn't isn't actually looking
at a factual case, so assuming that the case that doesn't happen does
happen is putting a false premise into your logic, which means it
doesn't actually prove anything.

FAIL.

>
> Unless English is your second language your very persistent inability to
> understand the difference between WOULD and DOES cannot be reasonably
> construed as any honest mistake.

And Code always DOES what it is programmed for, or at least it WOULD if
allowed to run for long enough.

You seem to be working with mythological Schrodinger Turing Machines
that don't have fixed behavior.

That is NOT allowed.

THe fact that you are so stupid and don't understand how programms
actually work makes we really doubt if you ever were a very good
programmer. I suppose that can be seen by how long it took you to try to
write you simulator, even starting from an already written on.

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.
When it does this it can stop its simulation of an otherwise infinite
computation and report that this computation would never halt.

void Infinite_Loop(int N)
{ HERE: goto HERE;
}

_Infinite_Loop()
[00000cb5](01) 55 push ebp
[00000cb6](02) 8bec mov ebp,esp
[00000cb8](02) ebfe jmp 00000cb8
[00000cba](01) 5d pop ebp
[00000cbb](01) c3 ret
Size in bytes:(0007) [00000cbb]

People that are dumber than a box of rocks may never be able to
correctly determine that the above computation would never reach its
final state at 00000cbb.

> A given coded algorithm will ALWAYS behave the same given the same
> input, so can't do both 'Never halt' and 'Abort and return an answer'.
>
> If you 'imagine' the code behaving one way, you need to actually use
> code that does that.
>
> It seems that
>
>>
>> If the infinite simulation WOULD NEVER HALT is not the same as DOES
>> NEVER STOP RUNNING.
>
> For this definition it is, or needs to be.
>
> Non-Halting is shown by a Machine (or UTM simulation of it) that WOULD
> NEVER HALT IF ALLOWED TO RUN FOREVER.
>
> We need to use WOULD, as we can't actually run forever.
>
> Since the only machine that the definition as an ACTUAL UTM, the meaning
> is the same.
>
> Note, your partial simulator, which doesn't see halting unless it aborts
> does NOT meet the requirement, because the way YOU look at it you are
> changing the behavior of the machine in multiple places.
>
> It is also the case the your partial simulator will either Abort its
> simulation or Not, so imagining that it doesn't isn't actually looking
> at a factual case, so assuming that the case that doesn't happen does
> happen is putting a false premise into your logic, which means it
> doesn't actually prove anything.
>
> FAIL.
>
>>
>> Unless English is your second language your very persistent inability
>> to understand the difference between WOULD and DOES cannot be
>> reasonably construed as any honest mistake.
>
> And Code always DOES what it is programmed for, or at least it WOULD if
> allowed to run for long enough.
>
> You seem to be working with mythological Schrodinger Turing Machines
> that don't have fixed behavior.
>
> That is NOT allowed.
>
> THe fact that you are so stupid and don't understand how programms
> actually work makes we really doubt if you ever were a very good
> programmer. I suppose that can be seen by how long it took you to try to
> write you simulator, even starting from an already written on.
>

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

You are presuming that Halting is Decidable to try to prove that it is.

FAIL.

> When it does this it can stop its simulation of an otherwise infinite
> computation and report that this computation would never halt.

But since it you made a false claim that you can predict, you get the
false answer that you can do this.

FAIL.

>
> void Infinite_Loop(int N)
> {
>   HERE: goto HERE;
> }
>
> _Infinite_Loop()
> [00000cb5](01)  55              push ebp
> [00000cb6](02)  8bec            mov ebp,esp
> [00000cb8](02)  ebfe            jmp 00000cb8
> [00000cba](01)  5d              pop ebp
> [00000cbb](01)  c3              ret
> Size in bytes:(0007) [00000cbb]

So you get 1 answer right, that was just a straw man.

>
> People that are dumber than a box of rocks may never be able to
> correctly determine that the above computation would never reach its
> final state at 00000cbb.

THAT makes it a Red Herring.

The problem is that the above machine is easily decideable.

H^ is NOT by the H it was built on.

FAIL.

GO FISH.

Your failure to point out any ACTUAL LOGIC error in any of the rebutals
to your statements which ARE pointing out ACTUAL LOGIC ERRORS in YOUR
logic shows that you have no ground that you know of to stand on.

YOU HAVE FAILED.

YOU FAILED YEARS AGO, but have been either too dumb, mentally
incompetent, or just too bull headed to see the truth.

Sounds like you are just going to have to die being wrong, and a
laughing stock of the community.

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.

> You are presuming that Halting is Decidable to try to prove that it is.
>
> FAIL.
>
>> When it does this it can stop its simulation of an otherwise infinite
>> computation and report that this computation would never halt.
>
> But since it you made a false claim that you can predict, you get the
> false answer that you can do this.
>
> FAIL.
>
>>
>> void Infinite_Loop(int N)
>> {
>>    HERE: goto HERE;
>> }
>>
>> _Infinite_Loop()
>> [00000cb5](01)  55              push ebp
>> [00000cb6](02)  8bec            mov ebp,esp
>> [00000cb8](02)  ebfe            jmp 00000cb8
>> [00000cba](01)  5d              pop ebp
>> [00000cbb](01)  c3              ret
>> Size in bytes:(0007) [00000cbb]
>
> So you get 1 answer right, that was just a straw man.
>
>>
>> People that are dumber than a box of rocks may never be able to
>> correctly determine that the above computation would never reach its
>> final state at 00000cbb.
>
> THAT makes it a Red Herring.
>
> The problem is that the above machine is easily decideable.
>
> H^ is NOT by the H it was built on.
>
> FAIL.
>
> GO FISH.
>
> Your failure to point out any ACTUAL LOGIC error in any of the rebutals
> to your statements which ARE pointing out ACTUAL LOGIC ERRORS in YOUR
> logic shows that you have no ground that you know of to stand on.
>
> YOU HAVE FAILED.
>
> YOU FAILED YEARS AGO, but have been either too dumb, mentally
> incompetent, or just too bull headed to see the truth.
>
> Sounds like you are just going to have to die being wrong, and a
> laughing stock of the community.

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.

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.

On 1/2/22 3:43 PM, olcott wrote:
> 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.

No, YOU don't want an Honest Dialogue, as you ignore all the points
where people point out your ACTUAL mistakes.

Ig you will not deal with people pointing out where you use the wrong
definitions or use invalid logic, then what dialog is possible.

HONEST dialog deals with FACTS.

If you want to claim to be working on the Halting Problem of Computation
Theory, you need to work within the definitions of Computation Theory,
and if people point out where you fail to do that, you need to either
show where they have an actual wrong definition, or are doing wrong logic.

The fact that you have in so many words actually admitted that you
haven't done any significant study of the field means you do need to
either accept the corrections people give you or find actual
AUTHORITATIVE sources that show your position is valid.

Your only recourse so far has been to resort to claims of your opinion
'of the meaning of the words', when it has been obvious that you don't
actually understand the meaning of the actual words, at least as used in
the field.

You really need to come to grips that you have just flat out WASTED too
many years of your life, of which you seem to have too little left.

If you keep up in your current manner, you are just going to die as a
disgraced man who has made himself into a laughing stock.

Maybe some of your ideas have a place, in the right forum, but you do
NOT have a refutation for the Halting Problem.

Are you going to make something of what you have left, or are you just
going to continue wasting it on a hopeless task.

On 1/2/2022 2:55 PM, Richard Damon wrote:
>
> On 1/2/22 3:43 PM, olcott wrote:
>> 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.
>
> No, YOU don't want an Honest Dialogue, as you ignore all the points
> where people point out your ACTUAL mistakes.
>
> Ig you will not deal with people pointing out where you use the wrong
> definitions or use invalid logic, then what dialog is possible.
>

It is always a matter that I explain your mistake and then you switch to
another mistake. around and around. You must be an atheist because a
believer knows the (eternal incineration) penalty for lying.

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.

These steps would keep repeating:
Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...

This proves that a human can detect that the simulation of the input to
embedded_H would never reach its final state.

computation that halts
....the Turing machine will halt whenever it enters a final state
(Linz:1990:234)

This proves that if embedded_H transitioned to Ĥ.qn is would be correct
because a human can tell the its input meets the Linz criteria of never
halting.

> HONEST dialog deals with FACTS.
>
> If you want to claim to be working on the Halting Problem of Computation
> Theory, you need to work within the definitions of Computation Theory,
> and if people point out where you fail to do that, you need to either
> show where they have an actual wrong definition, or are doing wrong logic.
>
> The fact that you have in so many words actually admitted that you
> haven't done any significant study of the field means you do need to
> either accept the corrections people give you or find actual
> AUTHORITATIVE sources that show your position is valid.
>
> Your only recourse so far has been to resort to claims of your opinion
> 'of the meaning of the words', when it has been obvious that you don't
> actually understand the meaning of the actual words, at least as used in
> the field.
>
> You really need to come to grips that you have just flat out WASTED too
> many years of your life, of which you seem to have too little left.
>
> If you keep up in your current manner, you are just going to die as a
> disgraced man who has made himself into a laughing stock.
>
> Maybe some of your ideas have a place, in the right forum, but you do
> NOT have a refutation for the Halting Problem.
>
> Are you going to make something of what you have left, or are you just
> going to continue wasting it on a hopeless task.

--
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 1/2/22 4:15 PM, olcott wrote:
> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>
>> On 1/2/22 3:43 PM, olcott wrote:
>>> 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.
>>
>> No, YOU don't want an Honest Dialogue, as you ignore all the points
>> where people point out your ACTUAL mistakes.
>>
>> Ig you will not deal with people pointing out where you use the wrong
>> definitions or use invalid logic, then what dialog is possible.
>>
>
> It is always a matter that I explain your mistake and then you switch to
> another mistake. around and around. You must be an atheist because a
> believer knows the (eternal incineration) penalty for lying.

No, it is ALWAYS a matter that you will not look at what people tell you
is wrong, but just repeat your error without actually looking at the
errors in your
>
> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.

Again. No need for a new name, but whatever.

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

Here we go again. You don't ever learn so you have DOOMED yourself.

>
> These steps would keep repeating:
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...

Yes, IF H behaves that way, it makes an H^ that works that way, and will
it is t

>
> This proves that a human can detect that the simulation of the input to
> embedded_H would never reach its final state.
>
> computation that halts
> ...the Turing machine will halt whenever it enters a final state
> (Linz:1990:234)
>
> This proves that if embedded_H transitioned to Ĥ.qn is would be correct
> because a human can tell the its input meets the Linz criteria of never
> halting.

Your Unicorn. You previously defined your H to NEVER abort. And yes, if
H is defined to NEVER abort, then its H^ in non-halting. but then H can
NEVER transition to H.qn

If you are now talking about some other H, then you also have a
different H^, so you previous proof doesn't count.

PLEASE SHOW ME A MACHINE THAT NEVER HALTS BUT ALSO STOPS.

Your 'proof' always requires you to 'assume' something that is impossible.

Which indicates how likely your answer is correct.

It is IMPOSSIBLY correct, because to be correct you first need to do
something IMPOSSIBLE.

FAIL.

>> HONEST dialog deals with FACTS.
>>
>> If you want to claim to be working on the Halting Problem of
>> Computation Theory, you need to work within the definitions of
>> Computation Theory, and if people point out where you fail to do that,
>> you need to either show where they have an actual wrong definition, or
>> are doing wrong logic.
>>
>> The fact that you have in so many words actually admitted that you
>> haven't done any significant study of the field means you do need to
>> either accept the corrections people give you or find actual
>> AUTHORITATIVE sources that show your position is valid.
>>
>> Your only recourse so far has been to resort to claims of your opinion
>> 'of the meaning of the words', when it has been obvious that you don't
>> actually understand the meaning of the actual words, at least as used
>> in the field.
>>
>> You really need to come to grips that you have just flat out WASTED
>> too many years of your life, of which you seem to have too little left.
>>
>> If you keep up in your current manner, you are just going to die as a
>> disgraced man who has made himself into a laughing stock.
>>
>> Maybe some of your ideas have a place, in the right forum, but you do
>> NOT have a refutation for the Halting Problem.
>>
>> Are you going to make something of what you have left, or are you just
>> going to continue wasting it on a hopeless task.
>
>

On 1/2/2022 3:25 PM, Richard Damon wrote:
> On 1/2/22 4:15 PM, olcott wrote:
>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>
>>> On 1/2/22 3:43 PM, olcott wrote:
>>>> 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.
>>>
>>> No, YOU don't want an Honest Dialogue, as you ignore all the points
>>> where people point out your ACTUAL mistakes.
>>>
>>> Ig you will not deal with people pointing out where you use the wrong
>>> definitions or use invalid logic, then what dialog is possible.
>>>
>>
>> It is always a matter that I explain your mistake and then you switch
>> to another mistake. around and around. You must be an atheist because
>> a believer knows the (eternal incineration) penalty for lying.
>
> No, it is ALWAYS a matter that you will not look at what people tell you
> is wrong, but just repeat your error without actually looking at the
> errors in your
>>
>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>
> Again. No need for a new name, but whatever.
>
>>
>> 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.
>
> Here we go again. You don't ever learn so you have DOOMED yourself.
>
>>
>> These steps would keep repeating:
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>
> Yes, IF H behaves that way, it makes an H^ that works that way, and will
> it is t
>
>>
>> This proves that a human can detect that the simulation of the input
>> to embedded_H would never reach its final state.
>>
>> computation that halts
>> ...the Turing machine will halt whenever it enters a final state
>> (Linz:1990:234)
>>
>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>> correct because a human can tell the its input meets the Linz criteria
>> of never halting.
>
> Your Unicorn. You previously defined your H to NEVER abort.

That you continue to lie about this is your eternal incinertion not
mine. If eternal incineration is true then it remains true even if you
don't believe in it.

I never ever defined H to never abort and you know that you lie about
this. It has always been about H predicting the future behavior of its
input in the purely hypothetical case that H would not abort its input.

> And yes, if
> H is defined to NEVER abort, then its H^ in non-halting. but then H can
> NEVER transition to H.qn
>
> If you are now talking about some other H, then you also have a
> different H^, so you previous proof doesn't count.
>
> PLEASE SHOW ME A MACHINE THAT NEVER HALTS BUT ALSO STOPS.
>
> Your 'proof' always requires you to 'assume' something that is impossible.
>
> Which indicates how likely your answer is correct.
>
> It is IMPOSSIBLY correct, because to be correct you first need to do
> something IMPOSSIBLE.
>
> FAIL.
>
>>> HONEST dialog deals with FACTS.
>>>
>>> If you want to claim to be working on the Halting Problem of
>>> Computation Theory, you need to work within the definitions of
>>> Computation Theory, and if people point out where you fail to do
>>> that, you need to either show where they have an actual wrong
>>> definition, or are doing wrong logic.
>>>
>>> The fact that you have in so many words actually admitted that you
>>> haven't done any significant study of the field means you do need to
>>> either accept the corrections people give you or find actual
>>> AUTHORITATIVE sources that show your position is valid.
>>>
>>> Your only recourse so far has been to resort to claims of your
>>> opinion 'of the meaning of the words', when it has been obvious that
>>> you don't actually understand the meaning of the actual words, at
>>> least as used in the field.
>>>
>>> You really need to come to grips that you have just flat out WASTED
>>> too many years of your life, of which you seem to have too little left.
>>>
>>> If you keep up in your current manner, you are just going to die as a
>>> disgraced man who has made himself into a laughing stock.
>>>
>>> Maybe some of your ideas have a place, in the right forum, but you do
>>> NOT have a refutation for the Halting Problem.
>>>
>>> Are you going to make something of what you have left, or are you
>>> just going to continue wasting it on a hopeless task.
>>
>>
>

--
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 1/2/22 4:32 PM, olcott wrote:
> On 1/2/2022 3:25 PM, Richard Damon wrote:
>> On 1/2/22 4:15 PM, olcott wrote:
>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>
>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>> 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.
>>>>
>>>> No, YOU don't want an Honest Dialogue, as you ignore all the points
>>>> where people point out your ACTUAL mistakes.
>>>>
>>>> Ig you will not deal with people pointing out where you use the
>>>> wrong definitions or use invalid logic, then what dialog is possible.
>>>>
>>>
>>> It is always a matter that I explain your mistake and then you switch
>>> to another mistake. around and around. You must be an atheist because
>>> a believer knows the (eternal incineration) penalty for lying.
>>
>> No, it is ALWAYS a matter that you will not look at what people tell
>> you is wrong, but just repeat your error without actually looking at
>> the errors in your
>>>
>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>
>> Again. No need for a new name, but whatever.
>>
>>>
>>> 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.
>>
>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>
>>>
>>> These steps would keep repeating:
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>> Yes, IF H behaves that way, it makes an H^ that works that way, and
>> will it is t
>>
>>>
>>> This proves that a human can detect that the simulation of the input
>>> to embedded_H would never reach its final state.
>>>
>>> computation that halts
>>> ...the Turing machine will halt whenever it enters a final state
>>> (Linz:1990:234)
>>>
>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>> correct because a human can tell the its input meets the Linz
>>> criteria of never halting.
>>
>> Your Unicorn. You previously defined your H to NEVER abort.
>
> That you continue to lie about this is your eternal incinertion not
> mine. If eternal incineration is true then it remains true even if you
> don't believe in it.

If I am lying, you can prove it be showing a program that actually does
this.

If I am not lying, then YOU are, and YOUR life is as you just described.

Think of your eternal soul's fate if you continue to deny that Truth.

>
> I never ever defined H to never abort and you know that you lie about
> this. It has always been about H predicting the future behavior of its
> input in the purely hypothetical case that H would not abort its input.

If H does abort, the assuming in simulates forever is the UNICORN. A
machine that DOES abort, can't be used to prove that a computation will
never halt.

It is REQUIRED to meet the requirements of Linz, that if H goes to H.qn,
that the H^ using it (as ALL H^ will do) will also go to H^.qn and Halt.

f H^ <H^> Halts, the H was not right to say that it wouldn't, which is
exactly what H <H^> <H^> -> H.qn says.

Remember the requirement on H? That H wM w -> H.qn iff M w never Halts.

Since in this case M == H^, wM == <H^>, w == <H^>, we have that to meet
the requirements we need that

H <H^> <H^> -> H.qn iff H^ <H^> Never Halts.

But since H -> H.qn means H^ -> H^.qn and Halts, this is not true.

Your H has FAILED to meet its requirements.

This also means that any 'proof' you have made that impiles that H was
right must have an error, unless you can point to the error in the above.

Isn't that your whole bases of finding a counter to Linz, to show that
his proof can't be right?

FAIL.

>

On 1/2/2022 4:00 PM, Richard Damon wrote:
>
> On 1/2/22 4:32 PM, olcott wrote:
>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>> On 1/2/22 4:15 PM, olcott wrote:
>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>> 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.
>>>>>
>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the points
>>>>> where people point out your ACTUAL mistakes.
>>>>>
>>>>> Ig you will not deal with people pointing out where you use the
>>>>> wrong definitions or use invalid logic, then what dialog is possible.
>>>>>
>>>>
>>>> It is always a matter that I explain your mistake and then you
>>>> switch to another mistake. around and around. You must be an atheist
>>>> because a believer knows the (eternal incineration) penalty for lying.
>>>
>>> No, it is ALWAYS a matter that you will not look at what people tell
>>> you is wrong, but just repeat your error without actually looking at
>>> the errors in your
>>>>
>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>>
>>> Again. No need for a new name, but whatever.
>>>
>>>>
>>>> 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.
>>>
>>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>>
>>>>
>>>> These steps would keep repeating:
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>> Yes, IF H behaves that way, it makes an H^ that works that way, and
>>> will it is t
>>>
>>>>
>>>> This proves that a human can detect that the simulation of the input
>>>> to embedded_H would never reach its final state.
>>>>
>>>> computation that halts
>>>> ...the Turing machine will halt whenever it enters a final state
>>>> (Linz:1990:234)
>>>>
>>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>>> correct because a human can tell the its input meets the Linz
>>>> criteria of never halting.
>>>
>>> Your Unicorn. You previously defined your H to NEVER abort.
>>
>> That you continue to lie about this is your eternal incinertion not
>> mine. If eternal incineration is true then it remains true even if you
>> don't believe in it.
>
> If I am lying, you can prove it be showing a program that actually does
> this.
>

I am saying that we know it is the case that the infinite simulation of
the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach the final state of
this input and on this basis we also know that if embedded_H WOULD
transition to Ĥ.qn it WOULD be correct.

The way that you lie is to deceitfully change what I said and then form
a rebuttal on the basis of this deceitful change.

> If I am not lying, then YOU are, and YOUR life is as you just described.
>
> Think of your eternal soul's fate if you continue to deny that Truth.
>
>>
>> I never ever defined H to never abort and you know that you lie about
>> this. It has always been about H predicting the future behavior of its
>> input in the purely hypothetical case that H would not abort its input.
>
> If H does abort, the assuming in simulates forever is the UNICORN. A
> machine that DOES abort, can't be used to prove that a computation will
> never halt.
>
> It is REQUIRED to meet the requirements of Linz, that if H goes to H.qn,
> that the H^ using it (as ALL H^ will do) will also go to H^.qn and Halt.
>
> f H^ <H^> Halts, the H was not right to say that it wouldn't, which is
> exactly what H <H^> <H^> -> H.qn says.
>
> Remember the requirement on H? That H wM w -> H.qn iff M w never Halts.
>
> Since in this case M == H^, wM == <H^>, w == <H^>, we have that to meet
> the requirements we need that
>
> H <H^> <H^> -> H.qn iff H^ <H^> Never Halts.
>
> But since  H -> H.qn means H^ -> H^.qn and Halts, this is not true.
>
> Your H has FAILED to meet its requirements.
>
> This also means that any 'proof' you have made that impiles that H was
> right must have an error, unless you can point to the error in the above.
>
> Isn't that your whole bases of finding a counter to Linz, to show that
> his proof can't be right?
>
> 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 1/2/22 5:13 PM, olcott wrote:
> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>
>> On 1/2/22 4:32 PM, olcott wrote:
>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>> 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.
>>>>>>
>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>
>>>>>> Ig you will not deal with people pointing out where you use the
>>>>>> wrong definitions or use invalid logic, then what dialog is possible.
>>>>>>
>>>>>
>>>>> It is always a matter that I explain your mistake and then you
>>>>> switch to another mistake. around and around. You must be an
>>>>> atheist because a believer knows the (eternal incineration) penalty
>>>>> for lying.
>>>>
>>>> No, it is ALWAYS a matter that you will not look at what people tell
>>>> you is wrong, but just repeat your error without actually looking at
>>>> the errors in your
>>>>>
>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.
>>>>
>>>> Again. No need for a new name, but whatever.
>>>>
>>>>>
>>>>> 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.
>>>>
>>>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>>>
>>>>>
>>>>> These steps would keep repeating:
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>> Yes, IF H behaves that way, it makes an H^ that works that way, and
>>>> will it is t
>>>>
>>>>>
>>>>> This proves that a human can detect that the simulation of the
>>>>> input to embedded_H would never reach its final state.
>>>>>
>>>>> computation that halts
>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>> (Linz:1990:234)
>>>>>
>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>>>> correct because a human can tell the its input meets the Linz
>>>>> criteria of never halting.
>>>>
>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>
>>> That you continue to lie about this is your eternal incinertion not
>>> mine. If eternal incineration is true then it remains true even if
>>> you don't believe in it.
>>
>> If I am lying, you can prove it be showing a program that actually
>> does this.
>>
>
> I am saying that we know it is the case that the infinite simulation of
> the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach the final state of
> this input and on this basis we also know that if embedded_H WOULD
> transition to Ĥ.qn it WOULD be correct.

You are doing double speak again.

If H/embedded_H doesn't abort its simulation, the we have shown that the
computation H^ <H^> is indeed non-halting, but since H doesn't abort its
simulation it never can give that answer.

It doesn't matter in this case that if 'magically' H did go to H.qn that
it would have the right answer, because it just doesn't do that.

On the other hand, if H/embedded_H DOES abort its simulation and goes to
H.qn, then we have a DIFFERENT H^, and BECAUSE H went to H.qn, that H^
will also go to H^.qn and HALT, and thus H was wrong.

You have intermixed two different definitions of behavior of H that can
not occur at the same time. This is just incoherent double-speak to try
to impute a falsehood.

>
> The way that you lie is to deceitfully change what I said and then form
> a rebuttal on the basis of this deceitful change.

Please point out what statement I have made that is FACTUALLY incorrect.

YOU are the one using double speak to imply a falsehood.

Can you provide an H that does what you speak, that if left on its own
would never reach the final state, but also correctly goes to H.qn

If not, STFU.

The fact that Non-Halting is the right answer for the Halt Decider that
can never give it is NOT a counter example for Linz, you claiming that
some how it is such a thing is just a big fat lie.

FAIL.

>
>
>> If I am not lying, then YOU are, and YOUR life is as you just described.
>>
>> Think of your eternal soul's fate if you continue to deny that Truth.
>>
>>>
>>> I never ever defined H to never abort and you know that you lie about
>>> this. It has always been about H predicting the future behavior of
>>> its input in the purely hypothetical case that H would not abort its
>>> input.
>>
>> If H does abort, the assuming in simulates forever is the UNICORN. A
>> machine that DOES abort, can't be used to prove that a computation
>> will never halt.
>>
>> It is REQUIRED to meet the requirements of Linz, that if H goes to
>> H.qn, that the H^ using it (as ALL H^ will do) will also go to H^.qn
>> and Halt.
>>
>> f H^ <H^> Halts, the H was not right to say that it wouldn't, which is
>> exactly what H <H^> <H^> -> H.qn says.
>>
>> Remember the requirement on H? That H wM w -> H.qn iff M w never Halts.
>>
>> Since in this case M == H^, wM == <H^>, w == <H^>, we have that to
>> meet the requirements we need that
>>
>> H <H^> <H^> -> H.qn iff H^ <H^> Never Halts.
>>
>> But since  H -> H.qn means H^ -> H^.qn and Halts, this is not true.
>>
>> Your H has FAILED to meet its requirements.
>>
>> This also means that any 'proof' you have made that impiles that H was
>> right must have an error, unless you can point to the error in the above.
>>
>> Isn't that your whole bases of finding a counter to Linz, to show that
>> his proof can't be right?
>>
>> FAIL.
>>
>>>
>
>

On 1/2/2022 4:26 PM, Richard Damon wrote:
> On 1/2/22 5:13 PM, olcott wrote:
>> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>>
>>> On 1/2/22 4:32 PM, olcott wrote:
>>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>>> 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.
>>>>>>>
>>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>>
>>>>>>> Ig you will not deal with people pointing out where you use the
>>>>>>> wrong definitions or use invalid logic, then what dialog is
>>>>>>> possible.
>>>>>>>
>>>>>>
>>>>>> It is always a matter that I explain your mistake and then you
>>>>>> switch to another mistake. around and around. You must be an
>>>>>> atheist because a believer knows the (eternal incineration)
>>>>>> penalty for lying.
>>>>>
>>>>> No, it is ALWAYS a matter that you will not look at what people
>>>>> tell you is wrong, but just repeat your error without actually
>>>>> looking at the errors in your
>>>>>>
>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>> embedded_H.
>>>>>
>>>>> Again. No need for a new name, but whatever.
>>>>>
>>>>>>
>>>>>> 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.
>>>>>
>>>>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>>>>
>>>>>>
>>>>>> These steps would keep repeating:
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>> Yes, IF H behaves that way, it makes an H^ that works that way, and
>>>>> will it is t
>>>>>
>>>>>>
>>>>>> This proves that a human can detect that the simulation of the
>>>>>> input to embedded_H would never reach its final state.
>>>>>>
>>>>>> computation that halts
>>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>>> (Linz:1990:234)
>>>>>>
>>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>>>>> correct because a human can tell the its input meets the Linz
>>>>>> criteria of never halting.
>>>>>
>>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>>
>>>> That you continue to lie about this is your eternal incinertion not
>>>> mine. If eternal incineration is true then it remains true even if
>>>> you don't believe in it.
>>>
>>> If I am lying, you can prove it be showing a program that actually
>>> does this.
>>>
>>
>> I am saying that we know it is the case that the infinite simulation
>> of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach the final state
>> of this input and on this basis we also know that if embedded_H WOULD
>> transition to Ĥ.qn it WOULD be correct.
>
> You are doing double speak again.
>

WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES
WOULD is not DOES

> If H/embedded_H doesn't abort its simulation, the we have shown that the
> computation H^ <H^> is indeed non-halting, but since H doesn't abort its
> simulation it never can give that answer.
>
> It doesn't matter in this case that if 'magically' H did go to H.qn that
> it would have the right answer, because it just doesn't do that.
>
> On the other hand, if H/embedded_H DOES abort its simulation and goes to
> H.qn, then we have a DIFFERENT H^, and BECAUSE H went to H.qn, that H^
> will also go to H^.qn and HALT, and thus H was wrong.
>
> You have intermixed two different definitions of behavior of H that can
> not occur at the same time. This is just incoherent double-speak to try
> to impute a falsehood.
>
>>
>> The way that you lie is to deceitfully change what I said and then
>> form a rebuttal on the basis of this deceitful change.
>
> Please point out what statement I have made that is FACTUALLY incorrect.
>
> YOU are the one using double speak to imply a falsehood.
>
> Can you provide an H that does what you speak, that if left on its own
> would never reach the final state, but also correctly goes to H.qn
>
> If not, STFU.
>
> The fact that Non-Halting is the right answer for the Halt Decider that
> can never give it is NOT a counter example for Linz, you claiming that
> some how it is such a thing is just a big fat lie.
>
> FAIL.
>
>>
>>
>>> If I am not lying, then YOU are, and YOUR life is as you just described.
>>>
>>> Think of your eternal soul's fate if you continue to deny that Truth.
>>>
>>>>
>>>> I never ever defined H to never abort and you know that you lie
>>>> about this. It has always been about H predicting the future
>>>> behavior of its input in the purely hypothetical case that H would
>>>> not abort its input.
>>>
>>> If H does abort, the assuming in simulates forever is the UNICORN. A
>>> machine that DOES abort, can't be used to prove that a computation
>>> will never halt.
>>>
>>> It is REQUIRED to meet the requirements of Linz, that if H goes to
>>> H.qn, that the H^ using it (as ALL H^ will do) will also go to H^.qn
>>> and Halt.
>>>
>>> f H^ <H^> Halts, the H was not right to say that it wouldn't, which
>>> is exactly what H <H^> <H^> -> H.qn says.
>>>
>>> Remember the requirement on H? That H wM w -> H.qn iff M w never Halts.
>>>
>>> Since in this case M == H^, wM == <H^>, w == <H^>, we have that to
>>> meet the requirements we need that
>>>
>>> H <H^> <H^> -> H.qn iff H^ <H^> Never Halts.
>>>
>>> But since  H -> H.qn means H^ -> H^.qn and Halts, this is not true.
>>>
>>> Your H has FAILED to meet its requirements.
>>>
>>> This also means that any 'proof' you have made that impiles that H
>>> was right must have an error, unless you can point to the error in
>>> the above.
>>>
>>> Isn't that your whole bases of finding a counter to Linz, to show
>>> that his proof can't be right?
>>>
>>> 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 1/2/22 5:28 PM, olcott wrote:
> On 1/2/2022 4:26 PM, Richard Damon wrote:
>> On 1/2/22 5:13 PM, olcott wrote:
>>> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>>>
>>>> On 1/2/22 4:32 PM, olcott wrote:
>>>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>>>
>>>>>>>> Ig you will not deal with people pointing out where you use the
>>>>>>>> wrong definitions or use invalid logic, then what dialog is
>>>>>>>> possible.
>>>>>>>>
>>>>>>>
>>>>>>> It is always a matter that I explain your mistake and then you
>>>>>>> switch to another mistake. around and around. You must be an
>>>>>>> atheist because a believer knows the (eternal incineration)
>>>>>>> penalty for lying.
>>>>>>
>>>>>> No, it is ALWAYS a matter that you will not look at what people
>>>>>> tell you is wrong, but just repeat your error without actually
>>>>>> looking at the errors in your
>>>>>>>
>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>> embedded_H.
>>>>>>
>>>>>> Again. No need for a new name, but whatever.
>>>>>>
>>>>>>>
>>>>>>> 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.
>>>>>>
>>>>>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>>>>>
>>>>>>>
>>>>>>> These steps would keep repeating:
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>> Yes, IF H behaves that way, it makes an H^ that works that way,
>>>>>> and will it is t
>>>>>>
>>>>>>>
>>>>>>> This proves that a human can detect that the simulation of the
>>>>>>> input to embedded_H would never reach its final state.
>>>>>>>
>>>>>>> computation that halts
>>>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>>>> (Linz:1990:234)
>>>>>>>
>>>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>>>>>> correct because a human can tell the its input meets the Linz
>>>>>>> criteria of never halting.
>>>>>>
>>>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>>>
>>>>> That you continue to lie about this is your eternal incinertion not
>>>>> mine. If eternal incineration is true then it remains true even if
>>>>> you don't believe in it.
>>>>
>>>> If I am lying, you can prove it be showing a program that actually
>>>> does this.
>>>>
>>>
>>> I am saying that we know it is the case that the infinite simulation
>>> of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach the final state
>>> of this input and on this basis we also know that if embedded_H WOULD
>>> transition to Ĥ.qn it WOULD be correct.
>>
>> You are doing double speak again.
>>
>
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES

Just shows you don't have any real rebut to say, or just so gaslit by
yourself that you aren't reading what people are saying, which is just
as bad.

FAIL.

>
>> If H/embedded_H doesn't abort its simulation, the we have shown that
>> the computation H^ <H^> is indeed non-halting, but since H doesn't
>> abort its simulation it never can give that answer.
>>
>> It doesn't matter in this case that if 'magically' H did go to H.qn
>> that it would have the right answer, because it just doesn't do that.
>>
>> On the other hand, if H/embedded_H DOES abort its simulation and goes
>> to H.qn, then we have a DIFFERENT H^, and BECAUSE H went to H.qn, that
>> H^ will also go to H^.qn and HALT, and thus H was wrong.
>>
>> You have intermixed two different definitions of behavior of H that
>> can not occur at the same time. This is just incoherent double-speak
>> to try to impute a falsehood.
>>
>>>
>>> The way that you lie is to deceitfully change what I said and then
>>> form a rebuttal on the basis of this deceitful change.
>>
>> Please point out what statement I have made that is FACTUALLY incorrect.
>>
>> YOU are the one using double speak to imply a falsehood.
>>
>> Can you provide an H that does what you speak, that if left on its own
>> would never reach the final state, but also correctly goes to H.qn
>>
>> If not, STFU.
>>
>> The fact that Non-Halting is the right answer for the Halt Decider
>> that can never give it is NOT a counter example for Linz, you claiming
>> that some how it is such a thing is just a big fat lie.
>>
>> FAIL.
>>
>>>
>>>
>>>> If I am not lying, then YOU are, and YOUR life is as you just
>>>> described.
>>>>
>>>> Think of your eternal soul's fate if you continue to deny that Truth.
>>>>
>>>>>
>>>>> I never ever defined H to never abort and you know that you lie
>>>>> about this. It has always been about H predicting the future
>>>>> behavior of its input in the purely hypothetical case that H would
>>>>> not abort its input.
>>>>
>>>> If H does abort, the assuming in simulates forever is the UNICORN. A
>>>> machine that DOES abort, can't be used to prove that a computation
>>>> will never halt.
>>>>
>>>> It is REQUIRED to meet the requirements of Linz, that if H goes to
>>>> H.qn, that the H^ using it (as ALL H^ will do) will also go to H^.qn
>>>> and Halt.
>>>>
>>>> f H^ <H^> Halts, the H was not right to say that it wouldn't, which
>>>> is exactly what H <H^> <H^> -> H.qn says.
>>>>
>>>> Remember the requirement on H? That H wM w -> H.qn iff M w never Halts.
>>>>
>>>> Since in this case M == H^, wM == <H^>, w == <H^>, we have that to
>>>> meet the requirements we need that
>>>>
>>>> H <H^> <H^> -> H.qn iff H^ <H^> Never Halts.
>>>>
>>>> But since  H -> H.qn means H^ -> H^.qn and Halts, this is not true.
>>>>
>>>> Your H has FAILED to meet its requirements.
>>>>
>>>> This also means that any 'proof' you have made that impiles that H
>>>> was right must have an error, unless you can point to the error in
>>>> the above.
>>>>
>>>> Isn't that your whole bases of finding a counter to Linz, to show
>>>> that his proof can't be right?
>>>>
>>>> FAIL.
>>>>
>>>>>
>>>
>>>
>>
>
>

On 1/2/22 5:28 PM, olcott wrote:
> On 1/2/2022 4:26 PM, Richard Damon wrote:
>> On 1/2/22 5:13 PM, olcott wrote:
>>> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>>>
>>>> On 1/2/22 4:32 PM, olcott wrote:
>>>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>>>
>>>>>>>> Ig you will not deal with people pointing out where you use the
>>>>>>>> wrong definitions or use invalid logic, then what dialog is
>>>>>>>> possible.
>>>>>>>>
>>>>>>>
>>>>>>> It is always a matter that I explain your mistake and then you
>>>>>>> switch to another mistake. around and around. You must be an
>>>>>>> atheist because a believer knows the (eternal incineration)
>>>>>>> penalty for lying.
>>>>>>
>>>>>> No, it is ALWAYS a matter that you will not look at what people
>>>>>> tell you is wrong, but just repeat your error without actually
>>>>>> looking at the errors in your
>>>>>>>
>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>> embedded_H.
>>>>>>
>>>>>> Again. No need for a new name, but whatever.
>>>>>>
>>>>>>>
>>>>>>> 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.
>>>>>>
>>>>>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>>>>>
>>>>>>>
>>>>>>> These steps would keep repeating:
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>> Yes, IF H behaves that way, it makes an H^ that works that way,
>>>>>> and will it is t
>>>>>>
>>>>>>>
>>>>>>> This proves that a human can detect that the simulation of the
>>>>>>> input to embedded_H would never reach its final state.
>>>>>>>
>>>>>>> computation that halts
>>>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>>>> (Linz:1990:234)
>>>>>>>
>>>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>>>>>> correct because a human can tell the its input meets the Linz
>>>>>>> criteria of never halting.
>>>>>>
>>>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>>>
>>>>> That you continue to lie about this is your eternal incinertion not
>>>>> mine. If eternal incineration is true then it remains true even if
>>>>> you don't believe in it.
>>>>
>>>> If I am lying, you can prove it be showing a program that actually
>>>> does this.
>>>>
>>>
>>> I am saying that we know it is the case that the infinite simulation
>>> of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach the final state
>>> of this input and on this basis we also know that if embedded_H WOULD
>>> transition to Ĥ.qn it WOULD be correct.
>>
>> You are doing double speak again.
>>
>
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES

And actually, in the sentence it is used in as the definition, they are
actually the same.

If the UTM WOULD halt, means that it DOES halt if let run long enough

If the UTM WOULD NOT halt, means that the UTM actually DOES NOT halt,
even it the UTM is allowed to run an unbounded number of steps.

If you are using it in a different sense, then YOU are the one misusing
the term and lying by doing so.

FAIL.

>
>> If H/embedded_H doesn't abort its simulation, the we have shown that
>> the computation H^ <H^> is indeed non-halting, but since H doesn't
>> abort its simulation it never can give that answer.
>>
>> It doesn't matter in this case that if 'magically' H did go to H.qn
>> that it would have the right answer, because it just doesn't do that.
>>
>> On the other hand, if H/embedded_H DOES abort its simulation and goes
>> to H.qn, then we have a DIFFERENT H^, and BECAUSE H went to H.qn, that
>> H^ will also go to H^.qn and HALT, and thus H was wrong.
>>
>> You have intermixed two different definitions of behavior of H that
>> can not occur at the same time. This is just incoherent double-speak
>> to try to impute a falsehood.
>>
>>>
>>> The way that you lie is to deceitfully change what I said and then
>>> form a rebuttal on the basis of this deceitful change.
>>
>> Please point out what statement I have made that is FACTUALLY incorrect.
>>
>> YOU are the one using double speak to imply a falsehood.
>>
>> Can you provide an H that does what you speak, that if left on its own
>> would never reach the final state, but also correctly goes to H.qn
>>
>> If not, STFU.
>>
>> The fact that Non-Halting is the right answer for the Halt Decider
>> that can never give it is NOT a counter example for Linz, you claiming
>> that some how it is such a thing is just a big fat lie.
>>
>> FAIL.
>>
>>>
>>>
>>>> If I am not lying, then YOU are, and YOUR life is as you just
>>>> described.
>>>>
>>>> Think of your eternal soul's fate if you continue to deny that Truth.
>>>>
>>>>>
>>>>> I never ever defined H to never abort and you know that you lie
>>>>> about this. It has always been about H predicting the future
>>>>> behavior of its input in the purely hypothetical case that H would
>>>>> not abort its input.
>>>>
>>>> If H does abort, the assuming in simulates forever is the UNICORN. A
>>>> machine that DOES abort, can't be used to prove that a computation
>>>> will never halt.
>>>>
>>>> It is REQUIRED to meet the requirements of Linz, that if H goes to
>>>> H.qn, that the H^ using it (as ALL H^ will do) will also go to H^.qn
>>>> and Halt.
>>>>
>>>> f H^ <H^> Halts, the H was not right to say that it wouldn't, which
>>>> is exactly what H <H^> <H^> -> H.qn says.
>>>>
>>>> Remember the requirement on H? That H wM w -> H.qn iff M w never Halts.
>>>>
>>>> Since in this case M == H^, wM == <H^>, w == <H^>, we have that to
>>>> meet the requirements we need that
>>>>
>>>> H <H^> <H^> -> H.qn iff H^ <H^> Never Halts.
>>>>
>>>> But since  H -> H.qn means H^ -> H^.qn and Halts, this is not true.
>>>>
>>>> Your H has FAILED to meet its requirements.
>>>>
>>>> This also means that any 'proof' you have made that impiles that H
>>>> was right must have an error, unless you can point to the error in
>>>> the above.
>>>>
>>>> Isn't that your whole bases of finding a counter to Linz, to show
>>>> that his proof can't be right?
>>>>
>>>> FAIL.
>>>>
>>>>>
>>>
>>>
>>
>
>

On 1/2/2022 4:52 PM, Richard Damon wrote:
> On 1/2/22 5:28 PM, olcott wrote:
>> On 1/2/2022 4:26 PM, Richard Damon wrote:
>>> On 1/2/22 5:13 PM, olcott wrote:
>>>> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/2/22 4:32 PM, olcott wrote:
>>>>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>>>>
>>>>>>>>> Ig you will not deal with people pointing out where you use the
>>>>>>>>> wrong definitions or use invalid logic, then what dialog is
>>>>>>>>> possible.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is always a matter that I explain your mistake and then you
>>>>>>>> switch to another mistake. around and around. You must be an
>>>>>>>> atheist because a believer knows the (eternal incineration)
>>>>>>>> penalty for lying.
>>>>>>>
>>>>>>> No, it is ALWAYS a matter that you will not look at what people
>>>>>>> tell you is wrong, but just repeat your error without actually
>>>>>>> looking at the errors in your
>>>>>>>>
>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>> embedded_H.
>>>>>>>
>>>>>>> Again. No need for a new name, but whatever.
>>>>>>>
>>>>>>>>
>>>>>>>> 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.
>>>>>>>
>>>>>>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>>>>>>
>>>>>>>>
>>>>>>>> These steps would keep repeating:
>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>
>>>>>>> Yes, IF H behaves that way, it makes an H^ that works that way,
>>>>>>> and will it is t
>>>>>>>
>>>>>>>>
>>>>>>>> This proves that a human can detect that the simulation of the
>>>>>>>> input to embedded_H would never reach its final state.
>>>>>>>>
>>>>>>>> computation that halts
>>>>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>>>>> (Linz:1990:234)
>>>>>>>>
>>>>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>>>>>>> correct because a human can tell the its input meets the Linz
>>>>>>>> criteria of never halting.
>>>>>>>
>>>>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>>>>
>>>>>> That you continue to lie about this is your eternal incinertion
>>>>>> not mine. If eternal incineration is true then it remains true
>>>>>> even if you don't believe in it.
>>>>>
>>>>> If I am lying, you can prove it be showing a program that actually
>>>>> does this.
>>>>>
>>>>
>>>> I am saying that we know it is the case that the infinite simulation
>>>> of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach the final state
>>>> of this input and on this basis we also know that if embedded_H
>>>> WOULD transition to Ĥ.qn it WOULD be correct.
>>>
>>> You are doing double speak again.
>>>
>>
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>> WOULD is not DOES
>
> And actually, in the sentence it is used in as the definition, they are
> actually the same.
>
> If the UTM WOULD halt, means that it DOES halt if let run long enough
>
> If the UTM WOULD NOT halt, means that the UTM actually DOES NOT halt,
> even it the UTM is allowed to run an unbounded number of steps.
>
> If you are using it in a different sense, then YOU are the one misusing
> the term and lying by doing so.
If the UTM would not halt then embedded_H halts and reports that the UTM
would not halt.

--
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 1/2/22 6:03 PM, olcott wrote:
> On 1/2/2022 4:52 PM, Richard Damon wrote:
>> On 1/2/22 5:28 PM, olcott wrote:
>>> On 1/2/2022 4:26 PM, Richard Damon wrote:
>>>> On 1/2/22 5:13 PM, olcott wrote:
>>>>> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/2/22 4:32 PM, olcott wrote:
>>>>>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>>>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>>>>>
>>>>>>>>>> Ig you will not deal with people pointing out where you use
>>>>>>>>>> the wrong definitions or use invalid logic, then what dialog
>>>>>>>>>> is possible.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is always a matter that I explain your mistake and then you
>>>>>>>>> switch to another mistake. around and around. You must be an
>>>>>>>>> atheist because a believer knows the (eternal incineration)
>>>>>>>>> penalty for lying.
>>>>>>>>
>>>>>>>> No, it is ALWAYS a matter that you will not look at what people
>>>>>>>> tell you is wrong, but just repeat your error without actually
>>>>>>>> looking at the errors in your
>>>>>>>>>
>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>> embedded_H.
>>>>>>>>
>>>>>>>> Again. No need for a new name, but whatever.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> These steps would keep repeating:
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>
>>>>>>>> Yes, IF H behaves that way, it makes an H^ that works that way,
>>>>>>>> and will it is t
>>>>>>>>
>>>>>>>>>
>>>>>>>>> This proves that a human can detect that the simulation of the
>>>>>>>>> input to embedded_H would never reach its final state.
>>>>>>>>>
>>>>>>>>> computation that halts
>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>
>>>>>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>>>>>>>> correct because a human can tell the its input meets the Linz
>>>>>>>>> criteria of never halting.
>>>>>>>>
>>>>>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>>>>>
>>>>>>> That you continue to lie about this is your eternal incinertion
>>>>>>> not mine. If eternal incineration is true then it remains true
>>>>>>> even if you don't believe in it.
>>>>>>
>>>>>> If I am lying, you can prove it be showing a program that actually
>>>>>> does this.
>>>>>>
>>>>>
>>>>> I am saying that we know it is the case that the infinite
>>>>> simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach the
>>>>> final state of this input and on this basis we also know that if
>>>>> embedded_H WOULD transition to Ĥ.qn it WOULD be correct.
>>>>
>>>> You are doing double speak again.
>>>>
>>>
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>
>> And actually, in the sentence it is used in as the definition, they
>> are actually the same.
>>
>> If the UTM WOULD halt, means that it DOES halt if let run long enough
>>
>> If the UTM WOULD NOT halt, means that the UTM actually DOES NOT halt,
>> even it the UTM is allowed to run an unbounded number of steps.
>>
>> If you are using it in a different sense, then YOU are the one
>> misusing the term and lying by doing so.
> If the UTM would not halt then embedded_H halts and reports that the UTM
> would not halt.
>

How does embedded_H know that the UTM will not Halt? That has been
proved impossible.

Also, as previously shown, if H DOES abort and return non-halting then
the UTM WILL Halt.

This means that your embedded_H CAN'T abort the simulation (and that
shows one of the contradictions that shows that a Halt Decider is
Impossible).

YOU need to prove that you can actually do this impossible thing, which
you have tried to do for years and failed. You can't just say you can do it.

FAIL.

On 1/2/22 6:03 PM, olcott wrote:
> On 1/2/2022 4:52 PM, Richard Damon wrote:
>> On 1/2/22 5:28 PM, olcott wrote:
>>> On 1/2/2022 4:26 PM, Richard Damon wrote:
>>>> On 1/2/22 5:13 PM, olcott wrote:
>>>>> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/2/22 4:32 PM, olcott wrote:
>>>>>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>>>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>>>>>
>>>>>>>>>> Ig you will not deal with people pointing out where you use
>>>>>>>>>> the wrong definitions or use invalid logic, then what dialog
>>>>>>>>>> is possible.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is always a matter that I explain your mistake and then you
>>>>>>>>> switch to another mistake. around and around. You must be an
>>>>>>>>> atheist because a believer knows the (eternal incineration)
>>>>>>>>> penalty for lying.
>>>>>>>>
>>>>>>>> No, it is ALWAYS a matter that you will not look at what people
>>>>>>>> tell you is wrong, but just repeat your error without actually
>>>>>>>> looking at the errors in your
>>>>>>>>>
>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>> embedded_H.
>>>>>>>>
>>>>>>>> Again. No need for a new name, but whatever.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> These steps would keep repeating:
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>
>>>>>>>> Yes, IF H behaves that way, it makes an H^ that works that way,
>>>>>>>> and will it is t
>>>>>>>>
>>>>>>>>>
>>>>>>>>> This proves that a human can detect that the simulation of the
>>>>>>>>> input to embedded_H would never reach its final state.
>>>>>>>>>
>>>>>>>>> computation that halts
>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>
>>>>>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>>>>>>>> correct because a human can tell the its input meets the Linz
>>>>>>>>> criteria of never halting.
>>>>>>>>
>>>>>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>>>>>
>>>>>>> That you continue to lie about this is your eternal incinertion
>>>>>>> not mine. If eternal incineration is true then it remains true
>>>>>>> even if you don't believe in it.
>>>>>>
>>>>>> If I am lying, you can prove it be showing a program that actually
>>>>>> does this.
>>>>>>
>>>>>
>>>>> I am saying that we know it is the case that the infinite
>>>>> simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach the
>>>>> final state of this input and on this basis we also know that if
>>>>> embedded_H WOULD transition to Ĥ.qn it WOULD be correct.
>>>>
>>>> You are doing double speak again.
>>>>
>>>
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>> WOULD is not DOES
>>
>> And actually, in the sentence it is used in as the definition, they
>> are actually the same.
>>
>> If the UTM WOULD halt, means that it DOES halt if let run long enough
>>
>> If the UTM WOULD NOT halt, means that the UTM actually DOES NOT halt,
>> even it the UTM is allowed to run an unbounded number of steps.
>>
>> If you are using it in a different sense, then YOU are the one
>> misusing the term and lying by doing so.
> If the UTM would not halt then embedded_H halts and reports that the UTM
> would not halt.
>

You mean you can't see the absurdity in your claim, IF you had a Halt
decider (to decide if the UTM will halt), you could build a Halt Decider
(to decide if H^ will halt).

Detecting that the UTM will never halt is exactly the problem that you
need to solve. So your method basically is trapped in an infinite
definition loop.

You need to decide if the UTM will halt, how do you plan to do that,
simulate it with another UTM and see if that simulation will halt or not?

On 1/2/2022 5:06 PM, Richard Damon wrote:
> On 1/2/22 6:03 PM, olcott wrote:
>> On 1/2/2022 4:52 PM, Richard Damon wrote:
>>> On 1/2/22 5:28 PM, olcott wrote:
>>>> On 1/2/2022 4:26 PM, Richard Damon wrote:
>>>>> On 1/2/22 5:13 PM, olcott wrote:
>>>>>> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/2/22 4:32 PM, olcott wrote:
>>>>>>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>>>>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>>>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>>>>>>
>>>>>>>>>>> Ig you will not deal with people pointing out where you use
>>>>>>>>>>> the wrong definitions or use invalid logic, then what dialog
>>>>>>>>>>> is possible.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is always a matter that I explain your mistake and then you
>>>>>>>>>> switch to another mistake. around and around. You must be an
>>>>>>>>>> atheist because a believer knows the (eternal incineration)
>>>>>>>>>> penalty for lying.
>>>>>>>>>
>>>>>>>>> No, it is ALWAYS a matter that you will not look at what people
>>>>>>>>> tell you is wrong, but just repeat your error without actually
>>>>>>>>> looking at the errors in your
>>>>>>>>>>
>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>> embedded_H.
>>>>>>>>>
>>>>>>>>> Again. No need for a new name, but whatever.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> Here we go again. You don't ever learn so you have DOOMED
>>>>>>>>> yourself.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>
>>>>>>>>> Yes, IF H behaves that way, it makes an H^ that works that way,
>>>>>>>>> and will it is t
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> This proves that a human can detect that the simulation of the
>>>>>>>>>> input to embedded_H would never reach its final state.
>>>>>>>>>>
>>>>>>>>>> computation that halts
>>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would
>>>>>>>>>> be correct because a human can tell the its input meets the
>>>>>>>>>> Linz criteria of never halting.
>>>>>>>>>
>>>>>>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>>>>>>
>>>>>>>> That you continue to lie about this is your eternal incinertion
>>>>>>>> not mine. If eternal incineration is true then it remains true
>>>>>>>> even if you don't believe in it.
>>>>>>>
>>>>>>> If I am lying, you can prove it be showing a program that
>>>>>>> actually does this.
>>>>>>>
>>>>>>
>>>>>> I am saying that we know it is the case that the infinite
>>>>>> simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach
>>>>>> the final state of this input and on this basis we also know that
>>>>>> if embedded_H WOULD transition to Ĥ.qn it WOULD be correct.
>>>>>
>>>>> You are doing double speak again.
>>>>>
>>>>
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>> WOULD is not DOES
>>>
>>> And actually, in the sentence it is used in as the definition, they
>>> are actually the same.
>>>
>>> If the UTM WOULD halt, means that it DOES halt if let run long enough
>>>
>>> If the UTM WOULD NOT halt, means that the UTM actually DOES NOT halt,
>>> even it the UTM is allowed to run an unbounded number of steps.
>>>
>>> If you are using it in a different sense, then YOU are the one
>>> misusing the term and lying by doing so.
>> If the UTM would not halt then embedded_H halts and reports that the
>> UTM would not halt.
>>
>
> How does embedded_H know that the UTM will not Halt? That has been
> proved impossible.
>

Because it is obvious to humans that UTM would not halt it is proven to
not be impossible. Impossible are things like square circles.

> Also, as previously shown, if H DOES abort and return non-halting then
> the UTM WILL Halt.
>

If (NO MATTER WHAT embedded_H ACTUALLY DOES) the pure simulation of the
input to embedded_H would never reach its final state if embedded_H
never aborts its simulation THEN THIS IS 100% COMPLETE PROOF THAT
embedded_H CAN TRANSITION TO Ĥ.qn CORRECTLY.

> This means that your embedded_H CAN'T abort the simulation (and that
> shows one of the contradictions that shows that a Halt Decider is
> Impossible).
>
> YOU need to prove that you can actually do this impossible thing, which
> you have tried to do for years and failed. You can't just say you can do
> it.
>
> 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 1/2/22 6:27 PM, olcott wrote:
> On 1/2/2022 5:06 PM, Richard Damon wrote:
>> On 1/2/22 6:03 PM, olcott wrote:
>>> On 1/2/2022 4:52 PM, Richard Damon wrote:
>>>> On 1/2/22 5:28 PM, olcott wrote:
>>>>> On 1/2/2022 4:26 PM, Richard Damon wrote:
>>>>>> On 1/2/22 5:13 PM, olcott wrote:
>>>>>>> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/2/22 4:32 PM, olcott wrote:
>>>>>>>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>>>>>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>>>>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>>>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>>>>>>>
>>>>>>>>>>>> Ig you will not deal with people pointing out where you use
>>>>>>>>>>>> the wrong definitions or use invalid logic, then what dialog
>>>>>>>>>>>> is possible.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is always a matter that I explain your mistake and then
>>>>>>>>>>> you switch to another mistake. around and around. You must be
>>>>>>>>>>> an atheist because a believer knows the (eternal
>>>>>>>>>>> incineration) penalty for lying.
>>>>>>>>>>
>>>>>>>>>> No, it is ALWAYS a matter that you will not look at what
>>>>>>>>>> people tell you is wrong, but just repeat your error without
>>>>>>>>>> actually looking at the errors in your
>>>>>>>>>>>
>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>>>>>> embedded_H.
>>>>>>>>>>
>>>>>>>>>> Again. No need for a new name, but whatever.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> Here we go again. You don't ever learn so you have DOOMED
>>>>>>>>>> yourself.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> These steps would keep repeating:
>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>
>>>>>>>>>> Yes, IF H behaves that way, it makes an H^ that works that
>>>>>>>>>> way, and will it is t
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> This proves that a human can detect that the simulation of
>>>>>>>>>>> the input to embedded_H would never reach its final state.
>>>>>>>>>>>
>>>>>>>>>>> computation that halts
>>>>>>>>>>> ...the Turing machine will halt whenever it enters a final
>>>>>>>>>>> state (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would
>>>>>>>>>>> be correct because a human can tell the its input meets the
>>>>>>>>>>> Linz criteria of never halting.
>>>>>>>>>>
>>>>>>>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>>>>>>>
>>>>>>>>> That you continue to lie about this is your eternal incinertion
>>>>>>>>> not mine. If eternal incineration is true then it remains true
>>>>>>>>> even if you don't believe in it.
>>>>>>>>
>>>>>>>> If I am lying, you can prove it be showing a program that
>>>>>>>> actually does this.
>>>>>>>>
>>>>>>>
>>>>>>> I am saying that we know it is the case that the infinite
>>>>>>> simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach
>>>>>>> the final state of this input and on this basis we also know that
>>>>>>> if embedded_H WOULD transition to Ĥ.qn it WOULD be correct.
>>>>>>
>>>>>> You are doing double speak again.
>>>>>>
>>>>>
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>> WOULD is not DOES
>>>>
>>>> And actually, in the sentence it is used in as the definition, they
>>>> are actually the same.
>>>>
>>>> If the UTM WOULD halt, means that it DOES halt if let run long enough
>>>>
>>>> If the UTM WOULD NOT halt, means that the UTM actually DOES NOT
>>>> halt, even it the UTM is allowed to run an unbounded number of steps.
>>>>
>>>> If you are using it in a different sense, then YOU are the one
>>>> misusing the term and lying by doing so.
>>> If the UTM would not halt then embedded_H halts and reports that the
>>> UTM would not halt.
>>>
>>
>> How does embedded_H know that the UTM will not Halt? That has been
>> proved impossible.
>>
>
> Because it is obvious to humans that UTM would not halt it is proven to
> not be impossible. Impossible are things like square circles.

Except it is proven that IF H goes to Qn, then the UTM WILL HALT.

The question is NOT what is the right answer that H can return.

The question is what is the right answer give an H, and what it will do.

As you have pointed out in the past, when you look at the design
question to figure out what H needs to do in this case, you end up in
the Liar's paradox, If H says Halting, the H^ will be non-halting, and
if H says Non-Halting then H^ will Halt, so no answer is correct. This
means that there IS no correct decider for the H^ based on it.

>
>> Also, as previously shown, if H DOES abort and return non-halting then
>> the UTM WILL Halt.
>>
>
> If (NO MATTER WHAT embedded_H ACTUALLY DOES) the pure simulation of the
> input to embedded_H would never reach its final state if embedded_H
> never aborts its simulation THEN THIS IS 100% COMPLETE PROOF THAT
> embedded_H CAN TRANSITION TO Ĥ.qn CORRECTLY.

NONSENSE SENTENCE!!! and double talk.