On 1/19/2022 7:19 PM, Richard Damon wrote:
> On 1/19/22 7:41 PM, olcott wrote:
>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>> On 1/19/22 10:18 AM, olcott wrote:
>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>
>>>> The key point that I have proved is if embedded_H does correctly
>>>> recognize an infinitely repeating behavior pattern in the behavior
>>>> of its simulated input then it is necessarily correct to abort the
>>>> simulation of the input and transition to Ĥ.qn.
>>>
>>> No, you haven't. Not by the definition of Computation Theory.
>>>
>>
>> You cannot possibly correctly disagree with a necessary truth.
>>
>> A simpler paraphrase of my words are this:
>>
>> If the input to embedded_H specifies a sequence of configurations that
>> never halt then it is necessarily correct for embedded_H to report
>> that its input specifies a sequence of configurations that never halt.
>>
>> This has the same logical form as: if X is a black cat then X is a cat.
>>
>>
>
> No, that statement is a LIE and a RED HERRING. I have never disagreed
> that IF the input to H specifies a sequense of configuration that will
> never halt that it is correct to say it is HALTING.
>
> What is NOT correct is that H can report that, because it has been shown
> that IF H goes to H.Qn, then the input does NOT specifiy a sequence that
> will never halt, because it specifies a sequence that does HALT.
>

You simply don't have the intellectual capacity to understand that
because a halt decider is a decider that it computes the mapping from
its input to an accept or reject state thus:

SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO RELEVANCE
WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS DETERMINATION.

--
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/19/22 8:47 PM, olcott wrote:
> On 1/19/2022 7:19 PM, Richard Damon wrote:
>> On 1/19/22 7:41 PM, olcott wrote:
>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>
>>>>> The key point that I have proved is if embedded_H does correctly
>>>>> recognize an infinitely repeating behavior pattern in the behavior
>>>>> of its simulated input then it is necessarily correct to abort the
>>>>> simulation of the input and transition to Ĥ.qn.
>>>>
>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>
>>>
>>> You cannot possibly correctly disagree with a necessary truth.
>>>
>>> A simpler paraphrase of my words are this:
>>>
>>> If the input to embedded_H specifies a sequence of configurations
>>> that never halt then it is necessarily correct for embedded_H to
>>> report that its input specifies a sequence of configurations that
>>> never halt.
>>>
>>> This has the same logical form as: if X is a black cat then X is a cat.
>>>
>>>
>>
>> No, that statement is a LIE and a RED HERRING. I have never disagreed
>> that IF the input to H specifies a sequense of configuration that will
>> never halt that it is correct to say it is HALTING.
>>
>> What is NOT correct is that H can report that, because it has been
>> shown that IF H goes to H.Qn, then the input does NOT specifiy a
>> sequence that will never halt, because it specifies a sequence that
>> does HALT.
>>
>
> You simply don't have the intellectual capacity to understand that
> because a halt decider is a decider that it computes the mapping from
> its input to an accept or reject state thus:
>
> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO RELEVANCE
> WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS DETERMINATION.
>

THAT is a LIE.

The input to H applied to <H^> <H^> is <H^> <H^> which repesents the
computation H^ applied to <H^>, and specifies EXACTLY the sequence that
that machine (or the equivalent UTM(<H^>,<H^>) go through.

You CAN'T complain that the sequences that UTM(<H^>,<H^>) don't
represent the sequence of configurations that are not actual inputs
because it LITERALLY IS THE set of SEQUENCES that the decider is
supposed to decide on.

FAIL.

You keep on getting stuck on the fact that it the correct answer is NOT
based on the set of sequences that H goes though with <H^> <H^>, but
what UTM(<H^>,<H^>) go though.

H can only USE the set of sequwnces that it goes through itself, but it
is responsible for the mapping that its definition refers to, which is
what UTM(<HT>,<H^>) goes through.

You seemed to have failed you class on requirements.

Remember, the mapping that H(x,y) is REQUIRED to compute to be correct
is the mapping determined by the results of UTM(x,y), but it can't
actually USE the UTM, as H needs to be quicker in deciding Non-Halting,
but still be 100% correct.

FAIL.

On 1/19/2022 8:01 PM, Richard Damon wrote:
> On 1/19/22 8:47 PM, olcott wrote:
>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>> On 1/19/22 7:41 PM, olcott wrote:
>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>
>>>>>> The key point that I have proved is if embedded_H does correctly
>>>>>> recognize an infinitely repeating behavior pattern in the behavior
>>>>>> of its simulated input then it is necessarily correct to abort the
>>>>>> simulation of the input and transition to Ĥ.qn.
>>>>>
>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>
>>>>
>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>
>>>> A simpler paraphrase of my words are this:
>>>>
>>>> If the input to embedded_H specifies a sequence of configurations
>>>> that never halt then it is necessarily correct for embedded_H to
>>>> report that its input specifies a sequence of configurations that
>>>> never halt.
>>>>
>>>> This has the same logical form as: if X is a black cat then X is a cat.
>>>>
>>>>
>>>
>>> No, that statement is a LIE and a RED HERRING. I have never disagreed
>>> that IF the input to H specifies a sequense of configuration that
>>> will never halt that it is correct to say it is HALTING.
>>>
>>> What is NOT correct is that H can report that, because it has been
>>> shown that IF H goes to H.Qn, then the input does NOT specifiy a
>>> sequence that will never halt, because it specifies a sequence that
>>> does HALT.
>>>
>>
>> You simply don't have the intellectual capacity to understand that
>> because a halt decider is a decider that it computes the mapping from
>> its input to an accept or reject state thus:
>>
>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO
>> RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS
>> DETERMINATION.
>>
>
> THAT is a LIE.
>

THIS IS SELF-EVIDENT TRUTH
If the simulated input to embedded_H never halts then embedded_H is
necessarily correct to report that it never halts.

--
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/19/22 9:08 PM, olcott wrote:
> On 1/19/2022 8:01 PM, Richard Damon wrote:
>> On 1/19/22 8:47 PM, olcott wrote:
>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>> The key point that I have proved is if embedded_H does correctly
>>>>>>> recognize an infinitely repeating behavior pattern in the
>>>>>>> behavior of its simulated input then it is necessarily correct to
>>>>>>> abort the simulation of the input and transition to Ĥ.qn.
>>>>>>
>>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>>
>>>>>
>>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>>
>>>>> A simpler paraphrase of my words are this:
>>>>>
>>>>> If the input to embedded_H specifies a sequence of configurations
>>>>> that never halt then it is necessarily correct for embedded_H to
>>>>> report that its input specifies a sequence of configurations that
>>>>> never halt.
>>>>>
>>>>> This has the same logical form as: if X is a black cat then X is a
>>>>> cat.
>>>>>
>>>>>
>>>>
>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>> disagreed that IF the input to H specifies a sequense of
>>>> configuration that will never halt that it is correct to say it is
>>>> HALTING.
>>>>
>>>> What is NOT correct is that H can report that, because it has been
>>>> shown that IF H goes to H.Qn, then the input does NOT specifiy a
>>>> sequence that will never halt, because it specifies a sequence that
>>>> does HALT.
>>>>
>>>
>>> You simply don't have the intellectual capacity to understand that
>>> because a halt decider is a decider that it computes the mapping from
>>> its input to an accept or reject state thus:
>>>
>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO
>>> RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS
>>> DETERMINATION.
>>>
>>
>> THAT is a LIE.
>>
>
> THIS IS SELF-EVIDENT TRUTH
> If the simulated input to embedded_H never halts then embedded_H is
> necessarily correct to report that it never halts.
>

Slightly wrong because it must be if the input to H was simulated by a
UTM and would never halt then it would be correct if H reported that it
never halts.

Keys are:

1) The fact that H can never see the Halting state doesn't matter, it is
only if the UTM never sees the halting.

2) The UTM is seeing the simulation based on the ACTUAL behavior of H,
not some hypothetical, so for H to be correct in reporting Non-Halting,
it needs to be correct that the UTM will never halt when simulating an
H^ built on an H that does abort it simulation and transition to H.Qn

3) We KNOW that if H -> H.Qn, then we know that H^ also goes to H^.Qn,
so if H does go to H.Qn then H^ Halts and H is thus wrong.

4) We also know that if H doesn't abort, then it fails to ever answer,
so it was not right reporting that H^ never halts, because it never gave
that answer.

So, you self evident truth doesn't actually prove the statement you want
it to prove.

It only would have been right for H to report non-halting in the case
where is didn't actual make that report, and if it does make that report
it is wrong, because then the UTM halts.

You don't think your answers through and just assume that your
impossible cases exist.

You are only correct in the land of Unicorns and fairy dust, which don't
exist, so you are not correct.

FAIL.

On 1/19/2022 8:26 PM, Richard Damon wrote:
> On 1/19/22 9:08 PM, olcott wrote:
>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>> On 1/19/22 8:47 PM, olcott wrote:
>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>> The key point that I have proved is if embedded_H does correctly
>>>>>>>> recognize an infinitely repeating behavior pattern in the
>>>>>>>> behavior of its simulated input then it is necessarily correct
>>>>>>>> to abort the simulation of the input and transition to Ĥ.qn.
>>>>>>>
>>>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>>>
>>>>>>
>>>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>>>
>>>>>> A simpler paraphrase of my words are this:
>>>>>>
>>>>>> If the input to embedded_H specifies a sequence of configurations
>>>>>> that never halt then it is necessarily correct for embedded_H to
>>>>>> report that its input specifies a sequence of configurations that
>>>>>> never halt.
>>>>>>
>>>>>> This has the same logical form as: if X is a black cat then X is a
>>>>>> cat.
>>>>>>
>>>>>>
>>>>>
>>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>>> disagreed that IF the input to H specifies a sequense of
>>>>> configuration that will never halt that it is correct to say it is
>>>>> HALTING.
>>>>>
>>>>> What is NOT correct is that H can report that, because it has been
>>>>> shown that IF H goes to H.Qn, then the input does NOT specifiy a
>>>>> sequence that will never halt, because it specifies a sequence that
>>>>> does HALT.
>>>>>
>>>>
>>>> You simply don't have the intellectual capacity to understand that
>>>> because a halt decider is a decider that it computes the mapping
>>>> from its input to an accept or reject state thus:
>>>>
>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO
>>>> RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS
>>>> DETERMINATION.
>>>>
>>>
>>> THAT is a LIE.
>>>
>>
>> THIS IS SELF-EVIDENT TRUTH
>> If the simulated input to embedded_H never halts then embedded_H is
>> necessarily correct to report that it never halts.
>>
>
> Slightly wrong because it must be if the input to H was simulated by a
> UTM and would never halt then it would be correct if H reported that it
> never halts.
>

Which in the case of this
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Means that embedded_H bases its halt status decision on what the
behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.

> Keys are:
>
> 1) The fact that H can never see the Halting state doesn't matter, it is
> only if the UTM never sees the halting.

embedded_H can see that the UTM will never see the final state without
embedded_H having to be an actual UTM. As soon as embedded_H sees an
infinitely repeating pattern then embedded_H knows that a UTM would
never see a final state.

--
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/19/22 9:39 PM, olcott wrote:
> On 1/19/2022 8:26 PM, Richard Damon wrote:
>> On 1/19/22 9:08 PM, olcott wrote:
>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>> correctly recognize an infinitely repeating behavior pattern in
>>>>>>>>> the behavior of its simulated input then it is necessarily
>>>>>>>>> correct to abort the simulation of the input and transition to
>>>>>>>>> Ĥ.qn.
>>>>>>>>
>>>>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>>>>
>>>>>>>
>>>>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>>>>
>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>
>>>>>>> If the input to embedded_H specifies a sequence of configurations
>>>>>>> that never halt then it is necessarily correct for embedded_H to
>>>>>>> report that its input specifies a sequence of configurations that
>>>>>>> never halt.
>>>>>>>
>>>>>>> This has the same logical form as: if X is a black cat then X is
>>>>>>> a cat.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>>>> disagreed that IF the input to H specifies a sequense of
>>>>>> configuration that will never halt that it is correct to say it is
>>>>>> HALTING.
>>>>>>
>>>>>> What is NOT correct is that H can report that, because it has been
>>>>>> shown that IF H goes to H.Qn, then the input does NOT specifiy a
>>>>>> sequence that will never halt, because it specifies a sequence
>>>>>> that does HALT.
>>>>>>
>>>>>
>>>>> You simply don't have the intellectual capacity to understand that
>>>>> because a halt decider is a decider that it computes the mapping
>>>>> from its input to an accept or reject state thus:
>>>>>
>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO
>>>>> RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS
>>>>> DETERMINATION.
>>>>>
>>>>
>>>> THAT is a LIE.
>>>>
>>>
>>> THIS IS SELF-EVIDENT TRUTH
>>> If the simulated input to embedded_H never halts then embedded_H is
>>> necessarily correct to report that it never halts.
>>>
>>
>> Slightly wrong because it must be if the input to H was simulated by a
>> UTM and would never halt then it would be correct if H reported that
>> it never halts.
>>
>
> Which in the case of this
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> Means that embedded_H bases its halt status decision on what the
> behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.

No, it doesn't

It means it needs to decide to MATCH the behavior of a UTM which it isn't.

IF you assume that there is a UTM at H^.qx then you are assuming either
that H is a UTM, or you are assuming the input isn't what the input is.

If H IS a UTM, you have proven that it will never halt and never answer,
so is wrong.

If you assume the input isn't what the input is, then you are not
solving the problem put before you and get the wrong answer.

FAIL

>
>> Keys are:
>>
>> 1) The fact that H can never see the Halting state doesn't matter, it
>> is only if the UTM never sees the halting.
>
> embedded_H can see that the UTM will never see the final state without
> embedded_H having to be an actual UTM. As soon as embedded_H sees an
> infinitely repeating pattern then embedded_H knows that a UTM would
> never see a final state.
>

But H ISN'T a UTM, so H isn't deciding based on the behavior of what it
actually needs to be deciding.

Youhave basically gone off and are just studing your POOP, not the
halting problem.

H needs to decide what its input ACTUAL does, when the contents of the
input match what it ACTUALLY is.

There is no assuming something is what it isn't, that doesn't lead to a
correct answer, except in your POOP.

Basically, you are showing that you don't understand a thing about what
you are talking about and just throwing monkey poo around to see if
something sticks.

All it shows is that you are wrong.

FAIL.

THe answer H(x,y) gives MUST match the behavior of UTM(x,y), going to Qy
if it hatls and Qn if it doesn't.

The problem is that because of the design of H^, if H goes to Qy, then
UTM will loop forever and H was wrong, and if H goes to Qn then the UTM
will Halt when H^ goes to Qn too, and H is still wrong.

The only way H can avoid giving a wrong answer is to never answer, but
then it fails at its other requirement, to give an answer in finite time.

Sorry, you POOP, and your logic, stinks.

On 1/19/2022 9:15 PM, Richard Damon wrote:
> On 1/19/22 9:39 PM, olcott wrote:
>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>> On 1/19/22 9:08 PM, olcott wrote:
>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>>> correctly recognize an infinitely repeating behavior pattern
>>>>>>>>>> in the behavior of its simulated input then it is necessarily
>>>>>>>>>> correct to abort the simulation of the input and transition to
>>>>>>>>>> Ĥ.qn.
>>>>>>>>>
>>>>>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>>>>>
>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>
>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>> configurations that never halt then it is necessarily correct
>>>>>>>> for embedded_H to report that its input specifies a sequence of
>>>>>>>> configurations that never halt.
>>>>>>>>
>>>>>>>> This has the same logical form as: if X is a black cat then X is
>>>>>>>> a cat.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>>>>> disagreed that IF the input to H specifies a sequense of
>>>>>>> configuration that will never halt that it is correct to say it
>>>>>>> is HALTING.
>>>>>>>
>>>>>>> What is NOT correct is that H can report that, because it has
>>>>>>> been shown that IF H goes to H.Qn, then the input does NOT
>>>>>>> specifiy a sequence that will never halt, because it specifies a
>>>>>>> sequence that does HALT.
>>>>>>>
>>>>>>
>>>>>> You simply don't have the intellectual capacity to understand that
>>>>>> because a halt decider is a decider that it computes the mapping
>>>>>> from its input to an accept or reject state thus:
>>>>>>
>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO
>>>>>> RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS
>>>>>> DETERMINATION.
>>>>>>
>>>>>
>>>>> THAT is a LIE.
>>>>>
>>>>
>>>> THIS IS SELF-EVIDENT TRUTH
>>>> If the simulated input to embedded_H never halts then embedded_H is
>>>> necessarily correct to report that it never halts.
>>>>
>>>
>>> Slightly wrong because it must be if the input to H was simulated by
>>> a UTM and would never halt then it would be correct if H reported
>>> that it never halts.
>>>
>>
>> Which in the case of this
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> Means that embedded_H bases its halt status decision on what the
>> behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>
> No, it doesn't
>
> It means it needs to decide to MATCH the behavior of a UTM which it isn't.
You keep making this same stupid mistake as if H could not possibly see
the infinitely repeating pattern of an infinite loop and thus must wait
forever for this never ending loop to stop running.

H always determines whether or not an infinite pure simulation of its
input would ever stop running and it always does this in a finite number
of steps.

--
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/19/22 10:29 PM, olcott wrote:
> On 1/19/2022 9:15 PM, Richard Damon wrote:
>> On 1/19/22 9:39 PM, olcott wrote:
>>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>>> On 1/19/22 9:08 PM, olcott wrote:
>>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>>>> correctly recognize an infinitely repeating behavior pattern
>>>>>>>>>>> in the behavior of its simulated input then it is necessarily
>>>>>>>>>>> correct to abort the simulation of the input and transition
>>>>>>>>>>> to Ĥ.qn.
>>>>>>>>>>
>>>>>>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>>>>>>
>>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>>
>>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>>> configurations that never halt then it is necessarily correct
>>>>>>>>> for embedded_H to report that its input specifies a sequence of
>>>>>>>>> configurations that never halt.
>>>>>>>>>
>>>>>>>>> This has the same logical form as: if X is a black cat then X
>>>>>>>>> is a cat.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>>>>>> disagreed that IF the input to H specifies a sequense of
>>>>>>>> configuration that will never halt that it is correct to say it
>>>>>>>> is HALTING.
>>>>>>>>
>>>>>>>> What is NOT correct is that H can report that, because it has
>>>>>>>> been shown that IF H goes to H.Qn, then the input does NOT
>>>>>>>> specifiy a sequence that will never halt, because it specifies a
>>>>>>>> sequence that does HALT.
>>>>>>>>
>>>>>>>
>>>>>>> You simply don't have the intellectual capacity to understand
>>>>>>> that because a halt decider is a decider that it computes the
>>>>>>> mapping from its input to an accept or reject state thus:
>>>>>>>
>>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO
>>>>>>> RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS
>>>>>>> DETERMINATION.
>>>>>>>
>>>>>>
>>>>>> THAT is a LIE.
>>>>>>
>>>>>
>>>>> THIS IS SELF-EVIDENT TRUTH
>>>>> If the simulated input to embedded_H never halts then embedded_H is
>>>>> necessarily correct to report that it never halts.
>>>>>
>>>>
>>>> Slightly wrong because it must be if the input to H was simulated by
>>>> a UTM and would never halt then it would be correct if H reported
>>>> that it never halts.
>>>>
>>>
>>> Which in the case of this
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> Means that embedded_H bases its halt status decision on what the
>>> behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>>
>> No, it doesn't
>>
>> It means it needs to decide to MATCH the behavior of a UTM which it
>> isn't.
> You keep making this same stupid mistake as if H could not possibly see
> the infinitely repeating pattern of an infinite loop and thus must wait
> forever for this never ending loop to stop running.
>
> H always determines whether or not an infinite pure simulation of its
> input would ever stop running and it always does this in a finite number
> of steps.
>

Yes, the problem is that if H never uses a bad rule and aborts with a
wrong answer, then H WILL keep on going and never stop running.

The is no basis to say that H ALWAYS determines whether or not an
infinite pure simulation of its input would never stop running. That is
the flaw in your arguement.

ANY finite pattern that H might attempt to show is non-halting, will, by
the contrary nature of H^ turn out to be halting, thus H if it refuses
to be wrong, can never abort and answer, and thus fails to be a decider.

To make your point you need to actually PROVE that a solution is
possible and not just ASSUME one is.

I have shown that it is impossible for there to be the finite pattern
that you just assume must exist.

That is why your logic FAILS.

If you disagree, SHOW THE PATTERN.

The problem is that as my prove showed, once H has that pattern, H^
knows that H will abort and say non-halting and thus Halts.

You keep going to the faulty logic that H^ is stopped when H aborts it,
but that is false, as the test of halting is by the UTM that is also
processing the input, and never aborts, and thus continues the execution
of H^ beyond the point H aborted it, which then uses its copy of H to
see that H will return non-halting and Halt.

FAIL.

On 1/19/2022 11:10 PM, Richard Damon wrote:
> On 1/19/22 10:29 PM, olcott wrote:
>> On 1/19/2022 9:15 PM, Richard Damon wrote:
>>> On 1/19/22 9:39 PM, olcott wrote:
>>>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>>>> On 1/19/22 9:08 PM, olcott wrote:
>>>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>>>>> correctly recognize an infinitely repeating behavior pattern
>>>>>>>>>>>> in the behavior of its simulated input then it is
>>>>>>>>>>>> necessarily correct to abort the simulation of the input and
>>>>>>>>>>>> transition to Ĥ.qn.
>>>>>>>>>>>
>>>>>>>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>>>>>>>
>>>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>>>
>>>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>>>> configurations that never halt then it is necessarily correct
>>>>>>>>>> for embedded_H to report that its input specifies a sequence
>>>>>>>>>> of configurations that never halt.
>>>>>>>>>>
>>>>>>>>>> This has the same logical form as: if X is a black cat then X
>>>>>>>>>> is a cat.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>>>>>>> disagreed that IF the input to H specifies a sequense of
>>>>>>>>> configuration that will never halt that it is correct to say it
>>>>>>>>> is HALTING.
>>>>>>>>>
>>>>>>>>> What is NOT correct is that H can report that, because it has
>>>>>>>>> been shown that IF H goes to H.Qn, then the input does NOT
>>>>>>>>> specifiy a sequence that will never halt, because it specifies
>>>>>>>>> a sequence that does HALT.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You simply don't have the intellectual capacity to understand
>>>>>>>> that because a halt decider is a decider that it computes the
>>>>>>>> mapping from its input to an accept or reject state thus:
>>>>>>>>
>>>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO
>>>>>>>> RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS
>>>>>>>> DETERMINATION.
>>>>>>>>
>>>>>>>
>>>>>>> THAT is a LIE.
>>>>>>>
>>>>>>
>>>>>> THIS IS SELF-EVIDENT TRUTH
>>>>>> If the simulated input to embedded_H never halts then embedded_H
>>>>>> is necessarily correct to report that it never halts.
>>>>>>
>>>>>
>>>>> Slightly wrong because it must be if the input to H was simulated
>>>>> by a UTM and would never halt then it would be correct if H
>>>>> reported that it never halts.
>>>>>
>>>>
>>>> Which in the case of this
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> Means that embedded_H bases its halt status decision on what the
>>>> behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>>>
>>> No, it doesn't
>>>
>>> It means it needs to decide to MATCH the behavior of a UTM which it
>>> isn't.
>> You keep making this same stupid mistake as if H could not possibly
>> see the infinitely repeating pattern of an infinite loop and thus must
>> wait forever for this never ending loop to stop running.
>>
>> H always determines whether or not an infinite pure simulation of its
>> input would ever stop running and it always does this in a finite
>> number of steps.
>>
>
> Yes, the problem is that if H never uses a bad rule and aborts with a
> wrong answer, then H WILL keep on going and never stop running.
>

That is a ridiculusly stupid thing to say.

> The is no basis to say that H ALWAYS determines whether or not an
> infinite pure simulation of its input would never stop running. That is
> the flaw in your arguement.
>

In the case in point is is obvious even to you that unless embedded_H
aborts its simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ that it would never stop
running. This by itself is complete proof that this input never halts.

> ANY finite pattern that H might attempt to show is non-halting, will, by
> the contrary nature of H^ turn out to be halting, thus H if it refuses
> to be wrong, can never abort and answer, and thus fails to be a decider.
>
> To make your point you need to actually PROVE that a solution is
> possible and not just ASSUME one is.
>
> I have shown that it is impossible for there to be the finite pattern
> that you just assume must exist.
>
> That is why your logic FAILS.
>
> If you disagree, SHOW THE PATTERN.
>
> The problem is that as my prove showed, once H has that pattern, H^
> knows that H will abort and say non-halting and thus Halts.
>
> You keep going to the faulty logic that H^ is stopped when H aborts it,
> but that is false, as the test of halting is by the UTM that is also
> processing the input, and never aborts, and thus continues the execution
> of H^ beyond the point H aborted it, which then uses its copy of H to
> see that H will return non-halting and Halt.
>
> 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 2022-01-20 00:41:11 +0000, olcott said:

> On 1/19/2022 6:24 PM, Richard Damon wrote:
>> No, you haven't. Not by the definition of Computation Theory
>
> You cannot possibly correctly disagree with a necessary truth.
>
> A simpler paraphrase of my words are this:
>
> If the input to embedded_H specifies a sequence of configurations that
> never halt then it is necessarily correct for embedded_H to report that
> its input specifies a sequence of configurations that never halt.
>
> This has the same logical form as: if X is a black cat then X is a cat.

No. It is more like this:
The image at https://media.clarkart.edu/Web_medium_images/1955.16.jpg
represents George Washington. There are no feet in the image, so one can
correctly say that George Washington had no feet.

Mikko

On 1/20/22 12:16 AM, olcott wrote:
> On 1/19/2022 11:10 PM, Richard Damon wrote:
>> On 1/19/22 10:29 PM, olcott wrote:
>>> On 1/19/2022 9:15 PM, Richard Damon wrote:
>>>> On 1/19/22 9:39 PM, olcott wrote:
>>>>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>>>>> On 1/19/22 9:08 PM, olcott wrote:
>>>>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>>>>>> correctly recognize an infinitely repeating behavior
>>>>>>>>>>>>> pattern in the behavior of its simulated input then it is
>>>>>>>>>>>>> necessarily correct to abort the simulation of the input
>>>>>>>>>>>>> and transition to Ĥ.qn.
>>>>>>>>>>>>
>>>>>>>>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>>>>>>>>
>>>>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>>>>
>>>>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>>>>> configurations that never halt then it is necessarily correct
>>>>>>>>>>> for embedded_H to report that its input specifies a sequence
>>>>>>>>>>> of configurations that never halt.
>>>>>>>>>>>
>>>>>>>>>>> This has the same logical form as: if X is a black cat then X
>>>>>>>>>>> is a cat.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>>>>>>>> disagreed that IF the input to H specifies a sequense of
>>>>>>>>>> configuration that will never halt that it is correct to say
>>>>>>>>>> it is HALTING.
>>>>>>>>>>
>>>>>>>>>> What is NOT correct is that H can report that, because it has
>>>>>>>>>> been shown that IF H goes to H.Qn, then the input does NOT
>>>>>>>>>> specifiy a sequence that will never halt, because it specifies
>>>>>>>>>> a sequence that does HALT.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You simply don't have the intellectual capacity to understand
>>>>>>>>> that because a halt decider is a decider that it computes the
>>>>>>>>> mapping from its input to an accept or reject state thus:
>>>>>>>>>
>>>>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO
>>>>>>>>> RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS
>>>>>>>>> DETERMINATION.
>>>>>>>>>
>>>>>>>>
>>>>>>>> THAT is a LIE.
>>>>>>>>
>>>>>>>
>>>>>>> THIS IS SELF-EVIDENT TRUTH
>>>>>>> If the simulated input to embedded_H never halts then embedded_H
>>>>>>> is necessarily correct to report that it never halts.
>>>>>>>
>>>>>>
>>>>>> Slightly wrong because it must be if the input to H was simulated
>>>>>> by a UTM and would never halt then it would be correct if H
>>>>>> reported that it never halts.
>>>>>>
>>>>>
>>>>> Which in the case of this
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> Means that embedded_H bases its halt status decision on what the
>>>>> behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>>>>
>>>> No, it doesn't
>>>>
>>>> It means it needs to decide to MATCH the behavior of a UTM which it
>>>> isn't.
>>> You keep making this same stupid mistake as if H could not possibly
>>> see the infinitely repeating pattern of an infinite loop and thus
>>> must wait forever for this never ending loop to stop running.
>>>
>>> H always determines whether or not an infinite pure simulation of its
>>> input would ever stop running and it always does this in a finite
>>> number of steps.
>>>
>>
>> Yes, the problem is that if H never uses a bad rule and aborts with a
>> wrong answer, then H WILL keep on going and never stop running.
>>
>
> That is a ridiculusly stupid thing to say.

Why? It is true, and has been proven. Care to point out the error in
that proof?

The stupid thing to say is that something 'must' be true and not be able
to show it.

>
>> The is no basis to say that H ALWAYS determines whether or not an
>> infinite pure simulation of its input would never stop running. That
>> is the flaw in your arguement.
>>
>
> In the case in point is is obvious even to you that unless embedded_H
> aborts its simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ that it would never stop
> running. This by itself is complete proof that this input never halts.

You keep on getting your logic wrong, don't you, and forgetting abot the
dependencies in the problem.

Yes, if H never aborts its simulation, then H and H^ are non-Halting,
that is true, and ANOTHER Halt Decider would be correct to indicate this
fact.

The problem with H doing this is that it is impossible for H to both
abort its simulation to indicate this fact AND and the same time never
abort its simulation.

That is like saying if my cat was a dog he could bark, therefore my cat
CAN bark.

This is one of your most common errors in your logic, you show that if A
is true then B is true (and B will only be true if A was true), but then
you turn and talk about something that implies A is not True, but you
still assume that B must still be true.

That just doesn't work. Your mind seems to be stuck in the universe of
Unicorns and Fairy Dust and can't see what is actually true.

FAIL.

>
>> ANY finite pattern that H might attempt to show is non-halting, will,
>> by the contrary nature of H^ turn out to be halting, thus H if it
>> refuses to be wrong, can never abort and answer, and thus fails to be
>> a decider.
>>
>> To make your point you need to actually PROVE that a solution is
>> possible and not just ASSUME one is.
>>
>> I have shown that it is impossible for there to be the finite pattern
>> that you just assume must exist.
>>
>> That is why your logic FAILS.
>>
>> If you disagree, SHOW THE PATTERN.
>>
>> The problem is that as my prove showed, once H has that pattern, H^
>> knows that H will abort and say non-halting and thus Halts.
>>
>> You keep going to the faulty logic that H^ is stopped when H aborts
>> it, but that is false, as the test of halting is by the UTM that is
>> also processing the input, and never aborts, and thus continues the
>> execution of H^ beyond the point H aborted it, which then uses its
>> copy of H to see that H will return non-halting and Halt.
>>
>> FAIL.
>>
>
>

On 1/20/2022 5:44 AM, Richard Damon wrote:
> On 1/20/22 12:16 AM, olcott wrote:
>> On 1/19/2022 11:10 PM, Richard Damon wrote:
>>> On 1/19/22 10:29 PM, olcott wrote:
>>>> On 1/19/2022 9:15 PM, Richard Damon wrote:
>>>>> On 1/19/22 9:39 PM, olcott wrote:
>>>>>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>>>>>> On 1/19/22 9:08 PM, olcott wrote:
>>>>>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>>>>>>> correctly recognize an infinitely repeating behavior
>>>>>>>>>>>>>> pattern in the behavior of its simulated input then it is
>>>>>>>>>>>>>> necessarily correct to abort the simulation of the input
>>>>>>>>>>>>>> and transition to Ĥ.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>>>>>>>>>
>>>>>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>>>>>
>>>>>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>>>>>> configurations that never halt then it is necessarily
>>>>>>>>>>>> correct for embedded_H to report that its input specifies a
>>>>>>>>>>>> sequence of configurations that never halt.
>>>>>>>>>>>>
>>>>>>>>>>>> This has the same logical form as: if X is a black cat then
>>>>>>>>>>>> X is a cat.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>>>>>>>>> disagreed that IF the input to H specifies a sequense of
>>>>>>>>>>> configuration that will never halt that it is correct to say
>>>>>>>>>>> it is HALTING.
>>>>>>>>>>>
>>>>>>>>>>> What is NOT correct is that H can report that, because it has
>>>>>>>>>>> been shown that IF H goes to H.Qn, then the input does NOT
>>>>>>>>>>> specifiy a sequence that will never halt, because it
>>>>>>>>>>> specifies a sequence that does HALT.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You simply don't have the intellectual capacity to understand
>>>>>>>>>> that because a halt decider is a decider that it computes the
>>>>>>>>>> mapping from its input to an accept or reject state thus:
>>>>>>>>>>
>>>>>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE NO
>>>>>>>>>> RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT STATUS
>>>>>>>>>> DETERMINATION.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> THAT is a LIE.
>>>>>>>>>
>>>>>>>>
>>>>>>>> THIS IS SELF-EVIDENT TRUTH
>>>>>>>> If the simulated input to embedded_H never halts then embedded_H
>>>>>>>> is necessarily correct to report that it never halts.
>>>>>>>>
>>>>>>>
>>>>>>> Slightly wrong because it must be if the input to H was simulated
>>>>>>> by a UTM and would never halt then it would be correct if H
>>>>>>> reported that it never halts.
>>>>>>>
>>>>>>
>>>>>> Which in the case of this
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> Means that embedded_H bases its halt status decision on what the
>>>>>> behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>>>>>
>>>>> No, it doesn't
>>>>>
>>>>> It means it needs to decide to MATCH the behavior of a UTM which it
>>>>> isn't.
>>>> You keep making this same stupid mistake as if H could not possibly
>>>> see the infinitely repeating pattern of an infinite loop and thus
>>>> must wait forever for this never ending loop to stop running.
>>>>
>>>> H always determines whether or not an infinite pure simulation of
>>>> its input would ever stop running and it always does this in a
>>>> finite number of steps.
>>>>
>>>
>>> Yes, the problem is that if H never uses a bad rule and aborts with a
>>> wrong answer, then H WILL keep on going and never stop running.
>>>
>>
>> That is a ridiculusly stupid thing to say.
>
> Why? It is true, and has been proven. Care to point out the error in
> that proof?
>
> The stupid thing to say is that something 'must' be true and not be able
> to show it.
>

You said it backwards. Aborting a program that would halt on its own
will not cause H to run forever.

>>
>>> The is no basis to say that H ALWAYS determines whether or not an
>>> infinite pure simulation of its input would never stop running. That
>>> is the flaw in your arguement.
>>>
>>
>> In the case in point is is obvious even to you that unless embedded_H
>> aborts its simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ that it would never stop
>> running. This by itself is complete proof that this input never halts.
>
> You keep on getting your logic wrong, don't you, and forgetting abot the
> dependencies in the problem.
>
> Yes, if H never aborts its simulation, then H and H^ are non-Halting,
> that is true, and ANOTHER Halt Decider would be correct to indicate this
> fact.
>

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

After I have corrected you fifty times on this you still get confused of
the difference between these two questions:
(1) Does the simulation of the input ever stop running?
(2) Can the simulated input ever reach its final state?

> The problem with H doing this is that it is impossible for H to both
> abort its simulation to indicate this fact AND and the same time never
> abort its simulation.
>
> That is like saying if my cat was a dog he could bark, therefore my cat
> CAN bark.
>

Not at all it is merely correctly answering the second question
(2) Can the simulated input ever reach its final state?

--
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/20/22 9:36 AM, olcott wrote:
> On 1/20/2022 5:44 AM, Richard Damon wrote:
>> On 1/20/22 12:16 AM, olcott wrote:
>>> On 1/19/2022 11:10 PM, Richard Damon wrote:
>>>> On 1/19/22 10:29 PM, olcott wrote:
>>>>> On 1/19/2022 9:15 PM, Richard Damon wrote:
>>>>>> On 1/19/22 9:39 PM, olcott wrote:
>>>>>>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>>>>>>> On 1/19/22 9:08 PM, olcott wrote:
>>>>>>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>>>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>>>>>>>> correctly recognize an infinitely repeating behavior
>>>>>>>>>>>>>>> pattern in the behavior of its simulated input then it is
>>>>>>>>>>>>>>> necessarily correct to abort the simulation of the input
>>>>>>>>>>>>>>> and transition to Ĥ.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, you haven't. Not by the definition of Computation Theory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You cannot possibly correctly disagree with a necessary truth.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>>>>>>> configurations that never halt then it is necessarily
>>>>>>>>>>>>> correct for embedded_H to report that its input specifies a
>>>>>>>>>>>>> sequence of configurations that never halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This has the same logical form as: if X is a black cat then
>>>>>>>>>>>>> X is a cat.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>>>>>>>>>> disagreed that IF the input to H specifies a sequense of
>>>>>>>>>>>> configuration that will never halt that it is correct to say
>>>>>>>>>>>> it is HALTING.
>>>>>>>>>>>>
>>>>>>>>>>>> What is NOT correct is that H can report that, because it
>>>>>>>>>>>> has been shown that IF H goes to H.Qn, then the input does
>>>>>>>>>>>> NOT specifiy a sequence that will never halt, because it
>>>>>>>>>>>> specifies a sequence that does HALT.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You simply don't have the intellectual capacity to understand
>>>>>>>>>>> that because a halt decider is a decider that it computes the
>>>>>>>>>>> mapping from its input to an accept or reject state thus:
>>>>>>>>>>>
>>>>>>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE
>>>>>>>>>>> NO RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT
>>>>>>>>>>> STATUS DETERMINATION.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> THAT is a LIE.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> THIS IS SELF-EVIDENT TRUTH
>>>>>>>>> If the simulated input to embedded_H never halts then
>>>>>>>>> embedded_H is necessarily correct to report that it never halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Slightly wrong because it must be if the input to H was
>>>>>>>> simulated by a UTM and would never halt then it would be correct
>>>>>>>> if H reported that it never halts.
>>>>>>>>
>>>>>>>
>>>>>>> Which in the case of this
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> Means that embedded_H bases its halt status decision on what the
>>>>>>> behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>>>>>>
>>>>>> No, it doesn't
>>>>>>
>>>>>> It means it needs to decide to MATCH the behavior of a UTM which
>>>>>> it isn't.
>>>>> You keep making this same stupid mistake as if H could not possibly
>>>>> see the infinitely repeating pattern of an infinite loop and thus
>>>>> must wait forever for this never ending loop to stop running.
>>>>>
>>>>> H always determines whether or not an infinite pure simulation of
>>>>> its input would ever stop running and it always does this in a
>>>>> finite number of steps.
>>>>>
>>>>
>>>> Yes, the problem is that if H never uses a bad rule and aborts with
>>>> a wrong answer, then H WILL keep on going and never stop running.
>>>>
>>>
>>> That is a ridiculusly stupid thing to say.
>>
>> Why? It is true, and has been proven. Care to point out the error in
>> that proof?
>>
>> The stupid thing to say is that something 'must' be true and not be
>> able to show it.
>>
>
> You said it backwards. Aborting a program that would halt on its own
> will not cause H to run forever.
>

Aborting the simulation of a program cause NO change in the actual
behavior of the program. PERIOD.

H^ <H^> WILL Halt if H aborts its simulaton of it and transitions to
H.Qn. That is establish fact.

>>>
>>>> The is no basis to say that H ALWAYS determines whether or not an
>>>> infinite pure simulation of its input would never stop running. That
>>>> is the flaw in your arguement.
>>>>
>>>
>>> In the case in point is is obvious even to you that unless embedded_H
>>> aborts its simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ that it would never stop
>>> running. This by itself is complete proof that this input never halts.
>>
>> You keep on getting your logic wrong, don't you, and forgetting abot
>> the dependencies in the problem.
>>
>> Yes, if H never aborts its simulation, then H and H^ are non-Halting,
>> that is true, and ANOTHER Halt Decider would be correct to indicate
>> this fact.
>>
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)

Right, when allowed to run as the ACTUAL machine (which means aborted
simulations don't tell us anything).

>
> After I have corrected you fifty times on this you still get confused of
> the difference between these two questions:
> (1) Does the simulation of the input ever stop running?
> (2) Can the simulated input ever reach its final state?

'simulation' in both of these case must be BY A UTM, it doesn't matter
what an H that might abort will do.

As pointed out, if H aborts its simulation are transitions to H.Qn then
the UTM simulated input WILL reach the state H^.Qn and Halt.

It doesn't matter that H never simulated it to that point.

On 1/20/2022 5:47 PM, Richard Damon wrote:
> On 1/20/22 9:36 AM, olcott wrote:
>> On 1/20/2022 5:44 AM, Richard Damon wrote:
>>> On 1/20/22 12:16 AM, olcott wrote:
>>>> On 1/19/2022 11:10 PM, Richard Damon wrote:
>>>>> On 1/19/22 10:29 PM, olcott wrote:
>>>>>> On 1/19/2022 9:15 PM, Richard Damon wrote:
>>>>>>> On 1/19/22 9:39 PM, olcott wrote:
>>>>>>>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>> On 1/19/22 9:08 PM, olcott wrote:
>>>>>>>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>>>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>>>>>>>>> correctly recognize an infinitely repeating behavior
>>>>>>>>>>>>>>>> pattern in the behavior of its simulated input then it
>>>>>>>>>>>>>>>> is necessarily correct to abort the simulation of the
>>>>>>>>>>>>>>>> input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, you haven't. Not by the definition of Computation
>>>>>>>>>>>>>>> Theory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You cannot possibly correctly disagree with a necessary
>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>>>>>>>> configurations that never halt then it is necessarily
>>>>>>>>>>>>>> correct for embedded_H to report that its input specifies
>>>>>>>>>>>>>> a sequence of configurations that never halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This has the same logical form as: if X is a black cat
>>>>>>>>>>>>>> then X is a cat.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, that statement is a LIE and a RED HERRING. I have never
>>>>>>>>>>>>> disagreed that IF the input to H specifies a sequense of
>>>>>>>>>>>>> configuration that will never halt that it is correct to
>>>>>>>>>>>>> say it is HALTING.
>>>>>>>>>>>>>
>>>>>>>>>>>>> What is NOT correct is that H can report that, because it
>>>>>>>>>>>>> has been shown that IF H goes to H.Qn, then the input does
>>>>>>>>>>>>> NOT specifiy a sequence that will never halt, because it
>>>>>>>>>>>>> specifies a sequence that does HALT.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You simply don't have the intellectual capacity to
>>>>>>>>>>>> understand that because a halt decider is a decider that it
>>>>>>>>>>>> computes the mapping from its input to an accept or reject
>>>>>>>>>>>> state thus:
>>>>>>>>>>>>
>>>>>>>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE
>>>>>>>>>>>> NO RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT
>>>>>>>>>>>> STATUS DETERMINATION.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> THAT is a LIE.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> THIS IS SELF-EVIDENT TRUTH
>>>>>>>>>> If the simulated input to embedded_H never halts then
>>>>>>>>>> embedded_H is necessarily correct to report that it never halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Slightly wrong because it must be if the input to H was
>>>>>>>>> simulated by a UTM and would never halt then it would be
>>>>>>>>> correct if H reported that it never halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Which in the case of this
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> Means that embedded_H bases its halt status decision on what the
>>>>>>>> behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>>>>>>>
>>>>>>> No, it doesn't
>>>>>>>
>>>>>>> It means it needs to decide to MATCH the behavior of a UTM which
>>>>>>> it isn't.
>>>>>> You keep making this same stupid mistake as if H could not
>>>>>> possibly see the infinitely repeating pattern of an infinite loop
>>>>>> and thus must wait forever for this never ending loop to stop
>>>>>> running.
>>>>>>
>>>>>> H always determines whether or not an infinite pure simulation of
>>>>>> its input would ever stop running and it always does this in a
>>>>>> finite number of steps.
>>>>>>
>>>>>
>>>>> Yes, the problem is that if H never uses a bad rule and aborts with
>>>>> a wrong answer, then H WILL keep on going and never stop running.
>>>>>
>>>>
>>>> That is a ridiculusly stupid thing to say.
>>>
>>> Why? It is true, and has been proven. Care to point out the error in
>>> that proof?
>>>
>>> The stupid thing to say is that something 'must' be true and not be
>>> able to show it.
>>>
>>
>> You said it backwards. Aborting a program that would halt on its own
>> will not cause H to run forever.
>>
>
> Aborting the simulation of a program cause NO change in the actual
> behavior of the program. PERIOD.
>

I don't see how you can say such ridiculously stupid things.

If an infinite loop is being simulated and this simulation is aborted
then you are saying that the infinite loop will keep on running even
though its simulation has been terminated.

> H^ <H^> WILL Halt if H aborts its simulaton of it and transitions to
> H.Qn. That is establish fact.
>

A halt decider, (like every decider) is only accountable for its inputs.
A halt decider, (like every decider) is only accountable for its inputs.
A halt decider, (like every decider) is only accountable for its inputs.
A halt decider, (like every decider) is only accountable for its inputs.
A halt decider, (like every decider) is only accountable for its inputs.

>>>>
>>>>> The is no basis to say that H ALWAYS determines whether or not an
>>>>> infinite pure simulation of its input would never stop running.
>>>>> That is the flaw in your arguement.
>>>>>
>>>>
>>>> In the case in point is is obvious even to you that unless
>>>> embedded_H aborts its simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ that it would
>>>> never stop running. This by itself is complete proof that this input
>>>> never halts.
>>>
>>> You keep on getting your logic wrong, don't you, and forgetting abot
>>> the dependencies in the problem.
>>>
>>> Yes, if H never aborts its simulation, then H and H^ are non-Halting,
>>> that is true, and ANOTHER Halt Decider would be correct to indicate
>>> this fact.
>>>
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>
> Right, when allowed to run as the ACTUAL machine (which means aborted
> simulations don't tell us anything).
>

On 1/20/22 7:13 PM, olcott wrote:
> On 1/20/2022 5:47 PM, Richard Damon wrote:
>> On 1/20/22 9:36 AM, olcott wrote:
>>> On 1/20/2022 5:44 AM, Richard Damon wrote:
>>>> On 1/20/22 12:16 AM, olcott wrote:
>>>>> On 1/19/2022 11:10 PM, Richard Damon wrote:
>>>>>> On 1/19/22 10:29 PM, olcott wrote:
>>>>>>> On 1/19/2022 9:15 PM, Richard Damon wrote:
>>>>>>>> On 1/19/22 9:39 PM, olcott wrote:
>>>>>>>>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>> On 1/19/22 9:08 PM, olcott wrote:
>>>>>>>>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>>>>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>>>>>>>>>> correctly recognize an infinitely repeating behavior
>>>>>>>>>>>>>>>>> pattern in the behavior of its simulated input then it
>>>>>>>>>>>>>>>>> is necessarily correct to abort the simulation of the
>>>>>>>>>>>>>>>>> input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, you haven't. Not by the definition of Computation
>>>>>>>>>>>>>>>> Theory.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You cannot possibly correctly disagree with a necessary
>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>>>>>>>>> configurations that never halt then it is necessarily
>>>>>>>>>>>>>>> correct for embedded_H to report that its input specifies
>>>>>>>>>>>>>>> a sequence of configurations that never halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This has the same logical form as: if X is a black cat
>>>>>>>>>>>>>>> then X is a cat.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, that statement is a LIE and a RED HERRING. I have
>>>>>>>>>>>>>> never disagreed that IF the input to H specifies a
>>>>>>>>>>>>>> sequense of configuration that will never halt that it is
>>>>>>>>>>>>>> correct to say it is HALTING.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What is NOT correct is that H can report that, because it
>>>>>>>>>>>>>> has been shown that IF H goes to H.Qn, then the input does
>>>>>>>>>>>>>> NOT specifiy a sequence that will never halt, because it
>>>>>>>>>>>>>> specifies a sequence that does HALT.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You simply don't have the intellectual capacity to
>>>>>>>>>>>>> understand that because a halt decider is a decider that it
>>>>>>>>>>>>> computes the mapping from its input to an accept or reject
>>>>>>>>>>>>> state thus:
>>>>>>>>>>>>>
>>>>>>>>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS HAVE
>>>>>>>>>>>>> NO RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE HALT
>>>>>>>>>>>>> STATUS DETERMINATION.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> THAT is a LIE.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> THIS IS SELF-EVIDENT TRUTH
>>>>>>>>>>> If the simulated input to embedded_H never halts then
>>>>>>>>>>> embedded_H is necessarily correct to report that it never halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Slightly wrong because it must be if the input to H was
>>>>>>>>>> simulated by a UTM and would never halt then it would be
>>>>>>>>>> correct if H reported that it never halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Which in the case of this
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> Means that embedded_H bases its halt status decision on what
>>>>>>>>> the behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>>>>>>>>
>>>>>>>> No, it doesn't
>>>>>>>>
>>>>>>>> It means it needs to decide to MATCH the behavior of a UTM which
>>>>>>>> it isn't.
>>>>>>> You keep making this same stupid mistake as if H could not
>>>>>>> possibly see the infinitely repeating pattern of an infinite loop
>>>>>>> and thus must wait forever for this never ending loop to stop
>>>>>>> running.
>>>>>>>
>>>>>>> H always determines whether or not an infinite pure simulation of
>>>>>>> its input would ever stop running and it always does this in a
>>>>>>> finite number of steps.
>>>>>>>
>>>>>>
>>>>>> Yes, the problem is that if H never uses a bad rule and aborts
>>>>>> with a wrong answer, then H WILL keep on going and never stop
>>>>>> running.
>>>>>>
>>>>>
>>>>> That is a ridiculusly stupid thing to say.
>>>>
>>>> Why? It is true, and has been proven. Care to point out the error in
>>>> that proof?
>>>>
>>>> The stupid thing to say is that something 'must' be true and not be
>>>> able to show it.
>>>>
>>>
>>> You said it backwards. Aborting a program that would halt on its own
>>> will not cause H to run forever.
>>>
>>
>> Aborting the simulation of a program cause NO change in the actual
>> behavior of the program. PERIOD.
>>
>
> I don't see how you can say such ridiculously stupid things.
>
> If an infinite loop is being simulated and this simulation is aborted
> then you are saying that the infinite loop will keep on running even
> though its simulation has been terminated.
>
>> H^ <H^> WILL Halt if H aborts its simulaton of it and transitions to
>> H.Qn. That is establish fact.
>>
>
> A halt decider, (like every decider) is only accountable for its inputs.
> A halt decider, (like every decider) is only accountable for its inputs.
> A halt decider, (like every decider) is only accountable for its inputs.
> A halt decider, (like every decider) is only accountable for its inputs.
> A halt decider, (like every decider) is only accountable for its inputs.
>
>>>>>
>>>>>> The is no basis to say that H ALWAYS determines whether or not an
>>>>>> infinite pure simulation of its input would never stop running.
>>>>>> That is the flaw in your arguement.
>>>>>>
>>>>>
>>>>> In the case in point is is obvious even to you that unless
>>>>> embedded_H aborts its simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ that it
>>>>> would never stop running. This by itself is complete proof that
>>>>> this input never halts.
>>>>
>>>> You keep on getting your logic wrong, don't you, and forgetting abot
>>>> the dependencies in the problem.
>>>>
>>>> Yes, if H never aborts its simulation, then H and H^ are
>>>> non-Halting, that is true, and ANOTHER Halt Decider would be correct
>>>> to indicate this fact.
>>>>
>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>
>> Right, when allowed to run as the ACTUAL machine (which means aborted
>> simulations don't tell us anything).
>>
>
> I giving up on you, you are either too freaking stupid or dishonest.

On 1/20/2022 6:20 PM, Richard Damon wrote:
> On 1/20/22 7:13 PM, olcott wrote:
>> On 1/20/2022 5:47 PM, Richard Damon wrote:
>>> On 1/20/22 9:36 AM, olcott wrote:
>>>> On 1/20/2022 5:44 AM, Richard Damon wrote:
>>>>> On 1/20/22 12:16 AM, olcott wrote:
>>>>>> On 1/19/2022 11:10 PM, Richard Damon wrote:
>>>>>>> On 1/19/22 10:29 PM, olcott wrote:
>>>>>>>> On 1/19/2022 9:15 PM, Richard Damon wrote:
>>>>>>>>> On 1/19/22 9:39 PM, olcott wrote:
>>>>>>>>>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/19/22 9:08 PM, olcott wrote:
>>>>>>>>>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The key point that I have proved is if embedded_H does
>>>>>>>>>>>>>>>>>> correctly recognize an infinitely repeating behavior
>>>>>>>>>>>>>>>>>> pattern in the behavior of its simulated input then it
>>>>>>>>>>>>>>>>>> is necessarily correct to abort the simulation of the
>>>>>>>>>>>>>>>>>> input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, you haven't. Not by the definition of Computation
>>>>>>>>>>>>>>>>> Theory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You cannot possibly correctly disagree with a necessary
>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>>>>>>>>>> configurations that never halt then it is necessarily
>>>>>>>>>>>>>>>> correct for embedded_H to report that its input
>>>>>>>>>>>>>>>> specifies a sequence of configurations that never halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This has the same logical form as: if X is a black cat
>>>>>>>>>>>>>>>> then X is a cat.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, that statement is a LIE and a RED HERRING. I have
>>>>>>>>>>>>>>> never disagreed that IF the input to H specifies a
>>>>>>>>>>>>>>> sequense of configuration that will never halt that it is
>>>>>>>>>>>>>>> correct to say it is HALTING.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What is NOT correct is that H can report that, because it
>>>>>>>>>>>>>>> has been shown that IF H goes to H.Qn, then the input
>>>>>>>>>>>>>>> does NOT specifiy a sequence that will never halt,
>>>>>>>>>>>>>>> because it specifies a sequence that does HALT.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You simply don't have the intellectual capacity to
>>>>>>>>>>>>>> understand that because a halt decider is a decider that
>>>>>>>>>>>>>> it computes the mapping from its input to an accept or
>>>>>>>>>>>>>> reject state thus:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS
>>>>>>>>>>>>>> HAVE NO RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE
>>>>>>>>>>>>>> HALT STATUS DETERMINATION.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> THAT is a LIE.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> THIS IS SELF-EVIDENT TRUTH
>>>>>>>>>>>> If the simulated input to embedded_H never halts then
>>>>>>>>>>>> embedded_H is necessarily correct to report that it never
>>>>>>>>>>>> halts.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Slightly wrong because it must be if the input to H was
>>>>>>>>>>> simulated by a UTM and would never halt then it would be
>>>>>>>>>>> correct if H reported that it never halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which in the case of this
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> Means that embedded_H bases its halt status decision on what
>>>>>>>>>> the behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>>>>>>>>>
>>>>>>>>> No, it doesn't
>>>>>>>>>
>>>>>>>>> It means it needs to decide to MATCH the behavior of a UTM
>>>>>>>>> which it isn't.
>>>>>>>> You keep making this same stupid mistake as if H could not
>>>>>>>> possibly see the infinitely repeating pattern of an infinite
>>>>>>>> loop and thus must wait forever for this never ending loop to
>>>>>>>> stop running.
>>>>>>>>
>>>>>>>> H always determines whether or not an infinite pure simulation
>>>>>>>> of its input would ever stop running and it always does this in
>>>>>>>> a finite number of steps.
>>>>>>>>
>>>>>>>
>>>>>>> Yes, the problem is that if H never uses a bad rule and aborts
>>>>>>> with a wrong answer, then H WILL keep on going and never stop
>>>>>>> running.
>>>>>>>
>>>>>>
>>>>>> That is a ridiculusly stupid thing to say.
>>>>>
>>>>> Why? It is true, and has been proven. Care to point out the error
>>>>> in that proof?
>>>>>
>>>>> The stupid thing to say is that something 'must' be true and not be
>>>>> able to show it.
>>>>>
>>>>
>>>> You said it backwards. Aborting a program that would halt on its own
>>>> will not cause H to run forever.
>>>>
>>>
>>> Aborting the simulation of a program cause NO change in the actual
>>> behavior of the program. PERIOD.
>>>
>>
>> I don't see how you can say such ridiculously stupid things.
>>
>> If an infinite loop is being simulated and this simulation is aborted
>> then you are saying that the infinite loop will keep on running even
>> though its simulation has been terminated.
>>
>>> H^ <H^> WILL Halt if H aborts its simulaton of it and transitions to
>>> H.Qn. That is establish fact.
>>>
>>
>> A halt decider, (like every decider) is only accountable for its inputs.
>> A halt decider, (like every decider) is only accountable for its inputs.
>> A halt decider, (like every decider) is only accountable for its inputs.
>> A halt decider, (like every decider) is only accountable for its inputs.
>> A halt decider, (like every decider) is only accountable for its inputs.
>>
>>>>>>
>>>>>>> The is no basis to say that H ALWAYS determines whether or not an
>>>>>>> infinite pure simulation of its input would never stop running.
>>>>>>> That is the flaw in your arguement.
>>>>>>>
>>>>>>
>>>>>> In the case in point is is obvious even to you that unless
>>>>>> embedded_H aborts its simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ that it
>>>>>> would never stop running. This by itself is complete proof that
>>>>>> this input never halts.
>>>>>
>>>>> You keep on getting your logic wrong, don't you, and forgetting
>>>>> abot the dependencies in the problem.
>>>>>
>>>>> Yes, if H never aborts its simulation, then H and H^ are
>>>>> non-Halting, that is true, and ANOTHER Halt Decider would be
>>>>> correct to indicate this fact.
>>>>>
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>
>>> Right, when allowed to run as the ACTUAL machine (which means aborted
>>> simulations don't tell us anything).
>>>
>>
>> I giving up on you, you are either too freaking stupid or dishonest.
>
> Because the behavior of a machine is defined by what it does when
> allowed to execute undisturbed.
>
> FAIL.
>
>>
>> It is not the fact that the input stopped running because it was
>> aborted that counts. It is the fact that embedded_H has correctly
>> matched a non-halting behavior pattern that conclusively proves that
>> its simulated input cannot possibly reach its final state.
>>
>
> Except that it did NOT correct match a correct pattern, as if H goes to
> H.Qn then H^ also goes to H^.Qn and Halts, and thus the pattern could
> not have been correct.
>

On 1/20/22 7:34 PM, olcott wrote:
> On 1/20/2022 6:20 PM, Richard Damon wrote:
>> On 1/20/22 7:13 PM, olcott wrote:
>>> On 1/20/2022 5:47 PM, Richard Damon wrote:
>>>> On 1/20/22 9:36 AM, olcott wrote:
>>>>> On 1/20/2022 5:44 AM, Richard Damon wrote:
>>>>>> On 1/20/22 12:16 AM, olcott wrote:
>>>>>>> On 1/19/2022 11:10 PM, Richard Damon wrote:
>>>>>>>> On 1/19/22 10:29 PM, olcott wrote:
>>>>>>>>> On 1/19/2022 9:15 PM, Richard Damon wrote:
>>>>>>>>>> On 1/19/22 9:39 PM, olcott wrote:
>>>>>>>>>>> On 1/19/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/19/22 9:08 PM, olcott wrote:
>>>>>>>>>>>>> On 1/19/2022 8:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/19/22 8:47 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/19/2022 7:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/19/22 7:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/19/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/19/22 10:18 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/18/2022 11:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The key point that I have proved is if embedded_H
>>>>>>>>>>>>>>>>>>> does correctly recognize an infinitely repeating
>>>>>>>>>>>>>>>>>>> behavior pattern in the behavior of its simulated
>>>>>>>>>>>>>>>>>>> input then it is necessarily correct to abort the
>>>>>>>>>>>>>>>>>>> simulation of the input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, you haven't. Not by the definition of Computation
>>>>>>>>>>>>>>>>>> Theory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You cannot possibly correctly disagree with a necessary
>>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A simpler paraphrase of my words are this:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If the input to embedded_H specifies a sequence of
>>>>>>>>>>>>>>>>> configurations that never halt then it is necessarily
>>>>>>>>>>>>>>>>> correct for embedded_H to report that its input
>>>>>>>>>>>>>>>>> specifies a sequence of configurations that never halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This has the same logical form as: if X is a black cat
>>>>>>>>>>>>>>>>> then X is a cat.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, that statement is a LIE and a RED HERRING. I have
>>>>>>>>>>>>>>>> never disagreed that IF the input to H specifies a
>>>>>>>>>>>>>>>> sequense of configuration that will never halt that it
>>>>>>>>>>>>>>>> is correct to say it is HALTING.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> What is NOT correct is that H can report that, because
>>>>>>>>>>>>>>>> it has been shown that IF H goes to H.Qn, then the input
>>>>>>>>>>>>>>>> does NOT specifiy a sequence that will never halt,
>>>>>>>>>>>>>>>> because it specifies a sequence that does HALT.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You simply don't have the intellectual capacity to
>>>>>>>>>>>>>>> understand that because a halt decider is a decider that
>>>>>>>>>>>>>>> it computes the mapping from its input to an accept or
>>>>>>>>>>>>>>> reject state thus:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> SEQUENCES OF CONFIGURATIONS THAT ARE NOT ACTUAL INPUTS
>>>>>>>>>>>>>>> HAVE NO RELEVANCE WHAT-SO-EVER TO THE CORRECTNESS OF THE
>>>>>>>>>>>>>>> HALT STATUS DETERMINATION.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> THAT is a LIE.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> THIS IS SELF-EVIDENT TRUTH
>>>>>>>>>>>>> If the simulated input to embedded_H never halts then
>>>>>>>>>>>>> embedded_H is necessarily correct to report that it never
>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Slightly wrong because it must be if the input to H was
>>>>>>>>>>>> simulated by a UTM and would never halt then it would be
>>>>>>>>>>>> correct if H reported that it never halts.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which in the case of this
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> Means that embedded_H bases its halt status decision on what
>>>>>>>>>>> the behavior of Ĥ applied to ⟨Ĥ⟩ would be if Ĥ.qx was a UTM.
>>>>>>>>>>
>>>>>>>>>> No, it doesn't
>>>>>>>>>>
>>>>>>>>>> It means it needs to decide to MATCH the behavior of a UTM
>>>>>>>>>> which it isn't.
>>>>>>>>> You keep making this same stupid mistake as if H could not
>>>>>>>>> possibly see the infinitely repeating pattern of an infinite
>>>>>>>>> loop and thus must wait forever for this never ending loop to
>>>>>>>>> stop running.
>>>>>>>>>
>>>>>>>>> H always determines whether or not an infinite pure simulation
>>>>>>>>> of its input would ever stop running and it always does this in
>>>>>>>>> a finite number of steps.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, the problem is that if H never uses a bad rule and aborts
>>>>>>>> with a wrong answer, then H WILL keep on going and never stop
>>>>>>>> running.
>>>>>>>>
>>>>>>>
>>>>>>> That is a ridiculusly stupid thing to say.
>>>>>>
>>>>>> Why? It is true, and has been proven. Care to point out the error
>>>>>> in that proof?
>>>>>>
>>>>>> The stupid thing to say is that something 'must' be true and not
>>>>>> be able to show it.
>>>>>>
>>>>>
>>>>> You said it backwards. Aborting a program that would halt on its
>>>>> own will not cause H to run forever.
>>>>>
>>>>
>>>> Aborting the simulation of a program cause NO change in the actual
>>>> behavior of the program. PERIOD.
>>>>
>>>
>>> I don't see how you can say such ridiculously stupid things.
>>>
>>> If an infinite loop is being simulated and this simulation is aborted
>>> then you are saying that the infinite loop will keep on running even
>>> though its simulation has been terminated.
>>>
>>>> H^ <H^> WILL Halt if H aborts its simulaton of it and transitions to
>>>> H.Qn. That is establish fact.
>>>>
>>>
>>> A halt decider, (like every decider) is only accountable for its inputs.
>>> A halt decider, (like every decider) is only accountable for its inputs.
>>> A halt decider, (like every decider) is only accountable for its inputs.
>>> A halt decider, (like every decider) is only accountable for its inputs.
>>> A halt decider, (like every decider) is only accountable for its inputs.
>>>
>>>>>>>
>>>>>>>> The is no basis to say that H ALWAYS determines whether or not
>>>>>>>> an infinite pure simulation of its input would never stop
>>>>>>>> running. That is the flaw in your arguement.
>>>>>>>>
>>>>>>>
>>>>>>> In the case in point is is obvious even to you that unless
>>>>>>> embedded_H aborts its simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ that it
>>>>>>> would never stop running. This by itself is complete proof that
>>>>>>> this input never halts.
>>>>>>
>>>>>> You keep on getting your logic wrong, don't you, and forgetting
>>>>>> abot the dependencies in the problem.
>>>>>>
>>>>>> Yes, if H never aborts its simulation, then H and H^ are
>>>>>> non-Halting, that is true, and ANOTHER Halt Decider would be
>>>>>> correct to indicate this fact.
>>>>>>
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> Right, when allowed to run as the ACTUAL machine (which means
>>>> aborted simulations don't tell us anything).
>>>>
>>>
>>> I giving up on you, you are either too freaking stupid or dishonest.
>>
>> Because the behavior of a machine is defined by what it does when
>> allowed to execute undisturbed.
>>
>> FAIL.
>>
>>>
>>> It is not the fact that the input stopped running because it was
>>> aborted that counts. It is the fact that embedded_H has correctly
>>> matched a non-halting behavior pattern that conclusively proves that
>>> its simulated input cannot possibly reach its final state.
>>>
>>
>> Except that it did NOT correct match a correct pattern, as if H goes
>> to H.Qn then H^ also goes to H^.Qn and Halts, and thus the pattern
>> could not have been correct.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> As long as embedded_H correctly determines that the simulated ⟨Ĥ⟩
> applied to ⟨Ĥ⟩ cannot possibly reach ITS final state
>
> NOTHING ELSE IN THE FREAKING UNIVERSE MAKES ANY DIFFERNCE AT ALL.