Analyzing the Peter Linz Halting Problem Proof

olcott

unread,

Oct 25, 2023, 6:25:57 PM10/25/23

to

https://www.liarparadox.org/Linz_Proof.pdf

This Turing Machine description at the top of page 3
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2

Is simplified and clarified to this:
when Ĥ is applied to ⟨Ĥ⟩

Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The advantage of the Linz proof is that it simultaneously represents
the entire infinite set of what would otherwise be an infinite set of
H/D pairs by using a single TM template for Ĥ.

*We can say that both yes and no are incorrect answers for every*
*embedded_H that attempts to answer the question*
Does the computation that I am contained within halt?

Any yes/no question that lacks a correct yes/no answer is an incorrect
question. The inability to correctly answer an incorrect question places
no limit on anyone or anything.

On the other hand when embedded_H is trying to answer the question:
Could my input terminate normally?
this question can be answered with a “no”.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Richard Damon

unread,

Oct 25, 2023, 6:51:35 PM10/25/23

to

On 10/25/23 3:25 PM, olcott wrote:
> https://www.liarparadox.org/Linz_Proof.pdf
>
> This Turing Machine description at the top of page 3
> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2

No, you are missing key details

q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞ IFF H WM WM went to qy
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2 IFF H WM WM went to qn

And H WM d is supposed to go to qy if M d will halt, and to qn if it
will not halt in a bounded number of steps to be correct.

>
> Is simplified and clarified to this:
> when Ĥ is applied to ⟨Ĥ⟩
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Again,

Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ IFF H ⟨Ĥ⟩ went to qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn IFF H ⟨Ĥ⟩ went to qn

>
> The advantage of the Linz proof is that it simultaneously represents
> the entire infinite set of what would otherwise be an infinite set of
> H/D pairs by using a single TM template for Ĥ.

Not quite, as H is a DEFINED machine, and embedded_H must be a copy of
that H.

>
> *We can say that both yes and no are incorrect answers for every*
> *embedded_H that attempts to answer the question*
> Does the computation that I am contained within halt?

So, that just means H and embedded_H are always wrong, what it the
problem with that.

The question was, can you make an H that was correct.

The question that H needs to answer is "Does the computation described
by the input Halt?", and if H goes to qn, the right answer is yes, and
if H goes to qy, the right answer is No, so there is always a correct
answer, its just that H never gives it for the input built by this formula.

>
> Any yes/no question that lacks a correct yes/no answer is an incorrect
> question. The inability to correctly answer an incorrect question places
> no limit on anyone or anything.

But you are asking the WRONG question.

The question ISN'T what does H / embedded_H need to return to be right,
but what is the correct answer for the given input.

>
> On the other hand when embedded_H is trying to answer the question:
> Could my input terminate normally?
> this question can be answered with a “no”.
>

But that isn't the right question, but a strawman.

In actuality, since your H goes to qn, then the RIGHT answer to the
halting question is YES the input represents a halting computation, so
it should have gone to qn.

You are just continuing to prove your stupidity.

You are just showing that you totally don't understand the nature of the
problem, by the parts you keep leaving out.

olcott

unread,

Oct 25, 2023, 7:01:37 PM10/25/23

to

On 10/25/2023 5:25 PM, olcott wrote:
> https://www.liarparadox.org/Linz_Proof.pdf
>
> This Turing Machine description at the top of page 3
> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>
> Is simplified and clarified to this:
> when Ĥ is applied to ⟨Ĥ⟩
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> The advantage of the Linz proof is that it simultaneously represents
> the entire infinite set of what would otherwise be an infinite set of
> H/D pairs by using a single TM template for Ĥ.
>
> *We can say that both yes and no are incorrect answers for every*
> *embedded_H that attempts to answer the question*
> Does the computation that I am contained within halt?

When we accept the idea of a pure function and that computations
must be pure functions then we know that it would be incorrect
for H to report on the computation that itself is contained within.

embedded_H cannot even see the computation that itself is contained
within it can only see the behavior of its actual input.

Richard Damon

unread,

Oct 25, 2023, 8:27:07 PM10/25/23

to

On 10/25/23 4:01 PM, olcott wrote:
> On 10/25/2023 5:25 PM, olcott wrote:
>> https://www.liarparadox.org/Linz_Proof.pdf
>>
>> This Turing Machine description at the top of page 3
>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>
>> Is simplified and clarified to this:
>> when Ĥ is applied to ⟨Ĥ⟩
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> The advantage of the Linz proof is that it simultaneously represents
>> the entire infinite set of what would otherwise be an infinite set of
>> H/D pairs by using a single TM template for Ĥ.
>>
>> *We can say that both yes and no are incorrect answers for every*
>> *embedded_H that attempts to answer the question*
>> Does the computation that I am contained within halt?
>
>
> When we accept the idea of a pure function and that computations
> must be pure functions then we know that it would be incorrect
> for H to report on the computation that itself is contained within.

Right, it is impossible to write an input that tries to actually use the
decider that is deciding on it, as such an input would not represent an
actual computation.

Thus, "the input" that the decider needs to decide on is always the
specific input of that problem, built on a specific decider, and that
input thus always has a defined behavior, and thus a correct answer.

Thus we START choosing a decider, and then we can built an input, and
that input WILL have a correct answer, it just is a fact that the
decider doesn't give it.

The fact the actual question, "Does the computation represented by the
input halt?" actually has a correct answer for every possible version of
this problem, means it is a valid question.

The fact that no decider can give the right answer for some particular
input, means that no decider is actually correct, and thus the problme
is uncomputable.

>
> embedded_H cannot even see the computation that itself is contained
> within it can only see the behavior of its actual input.
>

Right, it needs to answer about the computataion specified by the input.

And the fact that the computation specified by the input just happens to
match itself is thus irrelevent to the validity of the question, since
the problem statement is to try to handle ALL inputs, and this input is
a member of the input set.

You keep on trying to make the input dependent on the decider it is run
on, THAT is incorrect. The input is based on the decider that it was
built to prove wrong, and is thus a FIXED input, with an answer.

Your problem seems to be that you want to limit the behavior that H is
required to answer on to be something that it can actually compute.

You try to make Ĥ to not have a "correct" answer, but Ĥ isn't a decider,
so it doesn't need to have any particular answer. It just has defined
behavior, that H needs to correctly predict for *H* to be correct.

H is the machine that needs to have the "correct" behavior to be right,
and that behavior is fixed by the code the defines H.

The fact that we can't possibly write an H that gives the correct answer
to this particular input just means that the question is uncomputable,
not "invalid".

olcott

unread,

Oct 25, 2023, 8:55:09 PM10/25/23

Richard Damon

unread,

Oct 26, 2023, 12:04:27 AM10/26/23

to

So, you are admitting you are a stupid idiot?

>
> People that are not stupid idiots realize that ad
> hominem attacks from them directed at others make
> them look very foolish.
>
> AD Hominem attacks on others is a direct admission
> that one has run out of reasoning.
>

So, you don't understand what an ad hominem attack is!

Just shows how stupid you are.

Note, that ISN'T an ad hominem, because I am pointing out your stupidity
as being shown by the words you used, NOT claim you are wrong because
you are stupid.

You are just PROVING your stupidity.

Note, you can't even quote the statement you want to accuse me with.

I guess it is because you know it will show that you don't actually have
any ground to stand on.

As you continue to use invalid arguements, you are just proving your
ignorance of the system.

Sorry that you are so dumb.

Richard Damon

unread,

Oct 26, 2023, 12:10:11 AM10/26/23

to

Repeating your errors and not responding to the errors point out is just
an admission that you don't actually have any valid arguement, but are
just engaged in a "Big Lie" campaign and don't actually care about what
is true.

Igt CAN'T be wrong for embedded_H to report on the behavior of the
direct execution of Ĥ ⟨Ĥ⟩ if that is what the input represents. So, your
arguement is just based on LIES.

If the input is not a representation of this particular comuptation that
embedded_H is contained within, namely Ĥ ⟨Ĥ⟩, then your input is formed
incorrectly, and thus you are again shown to be a LIAR.

if (Ĥ) ⟨Ĥ⟩ is not the representation of Ĥ ⟨Ĥ⟩, then you are just shown
to be a LIAR in that you claim you have built the system by the rules of
the proof.

I guess you are just admitting you are just a stupid lying idiot because
you say what you have claimed can't be true, therefore you are calling
yourself a liar.

olcott

unread,

Oct 26, 2023, 12:25:06 AM10/26/23

to

Nothing but insults without any reasoning is one
of the stupidest things to do within the context
of fields having professional decorum.

Richard Damon

unread,

Oct 26, 2023, 12:33:50 AM10/26/23

to

The fact that you don't understand the reasoning that is being use to
support the insults, just proves they are correct.

Your refusal to quote them, implies you agree with that.

olcott

unread,

Oct 26, 2023, 12:34:12 AM10/26/23

to

People that understand that computable functions must be a pure
function of their inputs and thus are not allowed to report on
the computation that they are contained within also understand

that embedded_H is not allowed to report that the direct execution
of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.

We a few repetitions people that are not quite smart enough
eventually get this.

Richard Damon

unread,

Oct 26, 2023, 1:06:31 AM10/26/23

to

IF H / embedded_H is a pure function, how can it tell that it is being
called by Ĥ to change its behavior on the input (Ĥ) (Ĥ)?

The fact that is CAN'T means that you 'arguement' that the fact that the
input matches the machine it is part of is just a big fat LIE

The fat that you don't quote the message that point out your errors, but
you just repeat your erroneous claims show that you know tha tyou
arguments don't actually answer the problems reveiled.

You are just proving your stupidity.

olcott

unread,

Oct 26, 2023, 11:45:48 AM10/26/23

to

IF H / embedded_H is a pure function, how can it tell that it is being
called by Ĥ to change its behavior on the input (Ĥ) (Ĥ)?

It cannot, that is why it must rely on ⟨Ĥ⟩ correctly
simulated by embedded_H as its only valid measure.

embedded_H is expressly not allowed to consider that

Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.

Richard Damon

unread,

Oct 26, 2023, 2:54:37 PM10/26/23

to

It must give to correct answer to the problem given to it.

Where is the "rule" that says it can't consider that case? It *MUST*
consider that case or it violates the "All Inputs" requirement.

How can that possibly affect the behavior of the code that already
exists in H / embedded_H.

It only CAN use what it can compute, but the key is that it turns out
this is insufficient to actually be able to answer the question.

If embedded_H needs to rely on its correct simulation of the input, then
it needs to correctly simulate that input, which means its simulation
needs to reflect what the direct execution of the program the input
specifies will do. Since that program halts, since you claim H(D,D)
returns 0, that simulation must indicate the input is Halting, or the
simulation is incorrect, and embedded_H needs to blaim its own failing
to correctly simulate.

You want to ban the correct answer, because it shows that the
computation is impossible to do, but that it part of the question, *IS*
the computatoin possible.

You are just showing you don't understand that basics of computability,
or Truth, in your unfounded assumption that all quetions need to be
computable, or Truths provable.

Your illogical adherence to this false premise is just making you whole
logic system unsound and inconsistant.