olcott <NoOne@NoWhere.com> writes:

> On 6/20/2021 8:20 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 6/20/2021 6:49 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
>>>>> if M applied to wM halts, and
>>>>>
>>>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
>>>>> if M applied to wM does not halt
>>>>>
>>>>> Since I show exactly how the embedded halt decider at state Ĥ.qx
>>>>> correctly decides that its ⟨Ĥ⟩ input does not halt I have proved that
>>>>> Linz is wrong.
>>>> You are one tiny step away from understanding the proof. Put wM = <Ĥ>
>>>> (so M is Ĥ) and you get
>>>> Ĥ.q0 <Ĥ> ⊢* Ĥ.qx <Ĥ> <Ĥ> ⊢* Ĥ.qy ⊢* ∞
>>>> if Ĥ applied to <Ĥ> halts, and
>>>> Ĥ.q0 <Ĥ> ⊢* Ĥ.qx <Ĥ> <Ĥ> ⊢* Ĥ.qn
>>>> if Ĥ applied to <Ĥ> does not halt
>>>> I.e "Ĥ run (from state q0) on input <Ĥ> does not halt if Ĥ applied to
>>>> <Ĥ> halts", and "Ĥ run (from state q0) on input <Ĥ> halts (in state qn)
>>>> if Ĥ applied to <Ĥ> does not halt". Get it?
>>>
>>> Yes
>> Good, you get it. Now do something that's actually useful. You are a
>> dog lover. Go volunteer at a dog charity.
>>
>>> and "Ĥ run (from state q0) on input <Ĥ>...
>> No further remarks, however cast-iron they may be, can remove the
>> contradiction. If you've concluded (as you appear to have) that
>> assuming H to be correct leads to a contradiction, no number of other
>> correct (or even false) statements can stop a correct H from being
>> inherently contradictory.
>>
>>> SELF-EVIDENT-TRUTH
>>> Every computation that never halts unless its simulation is aborted is
>>> a computation that never halts.
>>>
>>> SELF-EVIDENT-TRUTH
>>> The <Ĥ> <Ĥ> input to the embedded halt decider at Ĥ.qx is a
>>> computation that never halts unless its simulation is aborted.
>> No further facts can remove the contradiction you have agreed to above.
>> Now some may dispute these "self-evident truths" but I don't need to.
>> They can be true, false or meaningless.
>
> We check the DNA of an animal and find that it perfectly matches a
> cat.

There are no actual barking cats. There is an assumption that you know
leads to a contradiction. The assumption must be rejected.

> When this animal barks we still know that it is definitely a cat and
> not at all a dog. The same applies to Ĥ applied to <Ĥ>.

The cat does not bark. You don't dispute the facts that

a. H(<[H^],[H^]>) (using my notation) is false, but
b. H^([H^]) halts.

In Linz's notation (as modified by you), your H and its H^ do not behave
as you state in the lines quote at the very top of this post.

You H is a clearly miaowing cat. There are lots of TMs X that get the
input <[X^],[X^]> wrong. You found one. Now got do something
worthwhile.

--
Ben.

On 6/21/2021 6:34 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 6/20/2021 8:20 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 6/20/2021 6:49 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
>>>>>> if M applied to wM halts, and
>>>>>>
>>>>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
>>>>>> if M applied to wM does not halt
>>>>>>
>>>>>> Since I show exactly how the embedded halt decider at state Ĥ.qx
>>>>>> correctly decides that its ⟨Ĥ⟩ input does not halt I have proved that
>>>>>> Linz is wrong.
>>>>> You are one tiny step away from understanding the proof. Put wM = <Ĥ>
>>>>> (so M is Ĥ) and you get
>>>>> Ĥ.q0 <Ĥ> ⊢* Ĥ.qx <Ĥ> <Ĥ> ⊢* Ĥ.qy ⊢* ∞
>>>>> if Ĥ applied to <Ĥ> halts, and
>>>>> Ĥ.q0 <Ĥ> ⊢* Ĥ.qx <Ĥ> <Ĥ> ⊢* Ĥ.qn
>>>>> if Ĥ applied to <Ĥ> does not halt
>>>>> I.e "Ĥ run (from state q0) on input <Ĥ> does not halt if Ĥ applied to
>>>>> <Ĥ> halts", and "Ĥ run (from state q0) on input <Ĥ> halts (in state qn)
>>>>> if Ĥ applied to <Ĥ> does not halt". Get it?
>>>>
>>>> Yes
>>> Good, you get it. Now do something that's actually useful. You are a
>>> dog lover. Go volunteer at a dog charity.
>>>
>>>> and "Ĥ run (from state q0) on input <Ĥ>...
>>> No further remarks, however cast-iron they may be, can remove the
>>> contradiction. If you've concluded (as you appear to have) that
>>> assuming H to be correct leads to a contradiction, no number of other
>>> correct (or even false) statements can stop a correct H from being
>>> inherently contradictory.
>>>
>>>> SELF-EVIDENT-TRUTH
>>>> Every computation that never halts unless its simulation is aborted is
>>>> a computation that never halts.
>>>>
>>>> SELF-EVIDENT-TRUTH
>>>> The <Ĥ> <Ĥ> input to the embedded halt decider at Ĥ.qx is a
>>>> computation that never halts unless its simulation is aborted.
>>> No further facts can remove the contradiction you have agreed to above.
>>> Now some may dispute these "self-evident truths" but I don't need to.
>>> They can be true, false or meaningless.
>>
>> We check the DNA of an animal and find that it perfectly matches a
>> cat.
>
> There are no actual barking cats. There is an assumption that you know
> leads to a contradiction. The assumption must be rejected.
>

Because the logic that determines that the Peter Linz Ĥ applied to the
Turing machine description of itself: ⟨Ĥ⟩ is correctly decided as
non-halting (is infallible) it is what appears to be the contradiction
that must be rejected as not an actual contradiction.

You have to actually pay attention to this logic to see that it is
actually infallible.

>> When this animal barks we still know that it is definitely a cat and
>> not at all a dog. The same applies to Ĥ applied to <Ĥ>.
>
> The cat does not bark. You don't dispute the facts that
>
> a. H(<[H^],[H^]>) (using my notation) is false, but
> b. H^([H^]) halts.

Ĥ(⟨Ĥ⟩) specifies an infinite chain of invocation that is terminated
at its third invocation. The first call from Ĥ(⟨Ĥ⟩) to H(⟨Ĥ⟩, ⟨Ĥ⟩) is
the first element of the infinite chain of invocations.

Everyone knows that when any invocation of an infinite chain of
invocations is terminated that the whole chain terminates. That the
first element of this infinite chain terminates after its third element
has been terminated does not entail that this first element is an actual
terminating computation.

For the first element to be an actual terminating computation it must
terminate without any of the other elements being terminated.

> In Linz's notation (as modified by you), your H and its H^ do not behave
> as you state in the lines quote at the very top of this post.
>

There is no H in my proof. We only have the copy of H at state Ĥ.qx.

> You H is a clearly miaowing cat. There are lots of TMs X that get the
> input <[X^],[X^]> wrong. You found one. Now got do something
> worthwhile.
>

By making sure to ignore the steps of my proof your fake attempt at
rebuttal continues to fool the gullible.

SELF-EVIDENT-TRUTH
Every computation that never halts unless its simulation is aborted is a
computation that never halts.

SELF-EVIDENT-TRUTH
The <Ĥ> <Ĥ> input to the embedded halt decider at Ĥ.qx is a computation
that never halts unless its simulation is aborted.

∴ IMPOSSIBLY FALSE CONCLUSION
The embedded simulating halt decider at Ĥ.qx correctly decides its
input: <Ĥ> <Ĥ> is a computation that never halts.

Halting problem undecidability and infinitely nested simulation

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/21/2021 6:27 AM, Richard Damon wrote:
> On 6/20/21 10:01 PM, olcott wrote:
>
>> None-the-less the Linz Ĥ has an infinite cycle in its state transition
>> diagram.
>>
>
> H^ only has an infinite cycle in its state transition diagram if H does.
> If H has that infinite cycle then it doesn't answer, and thus is is
> wrong without needing to see what H^ does.
>

There is no H, there is only the copy of H at internal state Ĥ.qx
I was not clear enough on this point so I rewrote it.

Halting problem undecidability and infinitely nested simulation

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

The embedded halt decider at state Ĥ.qx only has an infinitely cycle
when Ĥ is applied to ⟨Ĥ⟩.

> This is your fatal flaw, you don't keep H consistent between steps, H^
> only claims to confound ONE decider, so showing some other decider can
> decide it doesn't actually prove anything.
>
I am only showing how the embedded halt decider at state Ĥ.qx correctly
decides its input ⟨Ĥ⟩ otherwise we have the extraneous complexity of two
different halt deciders that must coordinate with each other.

> We don't need to disprove the H that doesn't abort H^, as it never
> answers so it can't be right.
>

The embedded halt decider at Ĥ.qx transitions to its final state of Ĥ.qn
after it has aborted the simulation of its input.

> Once we make the H have the simulation aborting behavior, we can show
> that if can't be smart enough to handle analyzing its own behavior.

The first grade teacher does not fire herself if her students perform
poorly on their tests. The teacher is only grading her students she is
not grading the conflation of her students and herself.

When answering the question:
Must the simulation of the input be aborted to prevent its infinite
execution?

The simulating halt decider acts as if it was a pure simulator until is
recognizes an infinitely repeating pattern.

> This
> is ALLOWED as H must come first, and any change in H forces the analysis
> to restart at the beginning as it changes H^.
>
> You make an erroneous equivalency argument and forget the limitations of
> it. This same sort of mistake allows all sorts of bad proofs of things
> like 1 == 2.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/21/21 9:59 AM, olcott wrote:
> On 6/21/2021 6:27 AM, Richard Damon wrote:
>> On 6/20/21 10:01 PM, olcott wrote:
>>
>>> None-the-less the Linz Ĥ has an infinite cycle in its state transition
>>> diagram.
>>>
>>
>> H^ only has an infinite cycle in its state transition diagram if H does.
>> If H has that infinite cycle then it doesn't answer, and thus is is
>> wrong without needing to see what H^ does.
>>
>
> There is no H, there is only the copy of H at internal state Ĥ.qx
> I was not clear enough on this point so I rewrote it.

Right, but is H never existed, the it never was a candidate for the
Decider of the Halting Problem. Automatic FAIL.

And, if H^ has an infinte loop in the code that is the copy of H, then
if you even pull that H out to try to claim it to be that halt decider,
it will fail to answer.

> Halting problem undecidability and infinitely nested simulation
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>
> The embedded halt decider at state Ĥ.qx only has an infinitely cycle
> when Ĥ is applied to ⟨Ĥ⟩.

WRONG. The state diagram of H^ is INDEPENDENT of its input. Maybe you
really don't understand Turing Machines.

The trace of what states if goes through will be a function, but again,
the only place in H^ where such an infinte loop would be would be inside
the code it copied from H, and it H^ gets stuck in an infinte loop, so
will H, so H will fail to answer.

>
>> This is your fatal flaw, you don't keep H consistent between steps, H^
>> only claims to confound ONE decider, so showing some other decider can
>> decide it doesn't actually prove anything.
>>
> I am only showing how the embedded halt decider at state Ĥ.qx correctly
> decides its input ⟨Ĥ⟩ otherwise we have the extraneous complexity of two
> different halt deciders that must coordinate with each other.
>

But you don't. The ONLY place that H^ can have an infinite loop is
inside H. If H reaches its answering state qn, then H^ will halt. Thus H
was wrong.

>> We don't need to disprove the H that doesn't abort H^, as it never
>> answers so it can't be right.
>>
>
> The embedded halt decider at Ĥ.qx transitions to its final state of Ĥ.qn
> after it has aborted the simulation of its input.

Right, then it goes to H^.qn, and H^ then Halts and shows that H gave
the wrong answer to the question of will H^(H^) Halt or be non-Halting.

WRONG IS WRONG.

Maybe it was right to the wrong question, but that is still wrong.

>
>> Once we make the H have the simulation aborting behavior, we can show
>> that if can't be smart enough to handle analyzing its own behavior.
>
> The first grade teacher does not fire herself if her students perform
> poorly on their tests. The teacher is only grading her students she is
> not grading the conflation of her students and herself.

What does that have to do with the price of Tea in China.

Once H is defined to be able to abort its simulation of H^, then for H
to correctly decide on H^, in needs to be able to consider that the copy
of H it is simulating may abort its own simulation.

It fails to do this, so it gets the wrong answer. YOU have used wrong
logic to derive that rule, so YOU are wrong too.

>
> When answering the question:
> Must the simulation of the input be aborted to prevent its infinite
> execution?

Where did that question come from? The Question of the Halting Problem
is does the machine P given the input I Halt in a finite number of steps
ore run forever.

Maybe if you look at the actual question you might be able to get the
right answer.

Can you show ANY reference to the use of this question, or can you only
blame yourself for this mistake?

>
> The simulating halt decider acts as if it was a pure simulator until is
> recognizes an infinitely repeating pattern.

And then it isn't one, so it made itself wrong. H doesn't know how to
analyze H.