Re: ChatGPT totally understands exactly how I refuted the conventional halting problem proof technique

On 6/29/2025 3:25 AM, Mikko wrote:

On 2025-06-28 12:56:04 +0000, olcott said:
 

On 6/28/2025 6:38 AM, Mikko wrote:

On 2025-06-27 15:22:50 +0000, olcott said:
>

On 6/26/2025 5:00 AM, Mikko wrote:

On 2025-06-25 15:26:28 +0000, olcott said:
>

On 6/25/2025 2:21 AM, Mikko wrote:

On 2025-06-24 21:41:37 +0000, olcott said:
>

On 6/24/2025 4:07 PM, joes wrote:

Am Tue, 24 Jun 2025 13:06:22 -0500 schrieb olcott:

On 6/24/2025 12:57 PM, joes wrote:

Am Tue, 24 Jun 2025 12:46:01 -0500 schrieb olcott:
>

It is an easily verified fact that no *input* to any partial halt
decider (PHD) can possibly do the opposite of what its corresponding
PHD decides. In all of the years of all of these proofs no such
*input* was ever presented.

>
You should clarify that you don't even think programs can be passed as
input.
>

It is common knowledge the no Turing Machine can take another directly
executed Turing Machine as an input.

So common that nobody would suggest such. You are the king of strawmen.

>
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
   if Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
   if Ĥ applied to ⟨Ĥ⟩ does not halt
>
Ĥ applied to ⟨Ĥ⟩ does not have embedded_H reporting on
the behavior specified by its input ⟨Ĥ⟩ ⟨Ĥ⟩ it has embedded_H
reporting on its own behavior.

>
As made clear in the source text, embedded_H does the same as
H when given the same input. The only difference is that if
that same behaviour reaches its qy state then H halts there
but Ĥ runs forever in a tight loop.

>
*You are not getting the main point*
The fact that Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to ⟨Ĥ.qn⟩ is
not contradicted by the fact that Ĥ.embedded_H itself halts.

>
That is not the main point.

>
It is the *only* reason why
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
is incorrectly construed as being incorrect.

>
It is neither correct nor incorrect. There are no requirements about Ĥ.

>
The above shows that Ĥ.embedded_H decided not halting.
This is either correct or incorrect depending on the
criterion measure.

 No, there is a third possibility: it is irrelevant if the criteria
don't say anything about that.
 

If Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ is to report on the behavior
that its inputs specify then transitioning to Ĥ.qn
is correct.

 If. The proof of unprovability does not specify any requirement
about that.
 

When it is understood that the directly executing
Ĥ applied to ⟨Ĥ⟩ is not in the domain of Ĥ.embedded_H
then the behavior of Ĥ applied to ⟨Ĥ⟩ does not contradict
the reporting of non-halting.

 Whatever embedded_H reports does not not contradict anyting specified
in the proof of uncomputability of halting.
 

The main point is that Ĥ ⟨Ĥ⟩ halts if
iH ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn but not if H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to
Ĥ.qy. Anything said about embedded_H is merely an intermediate
step in the proof of the main point if not totally irrelevant.
>

Because Ĥ.embedded_H cannot possibly take any directly
executing TM as its input that makes the behavior of
Ĥ applied to ⟨Ĥ⟩ outside of the domain of Ĥ.embedded_H.

>
Irrelevant. It can and does take the same input as H and from that
computes the same as H. That is all that is needed for the proof.
>

Since Turing Machines cannot take directly executing
Turing Machines as inputs this means that the directly
executed Ĥ applied to ⟨Ĥ⟩ is not in the domain of
Ĥ.embedded_H, *thus no contradiction is ever formed*

>
False. That Turing Machines cannot take directly executing
Turing Machnes as inputs is irrelevant.

>
Directly executing TM's are not in the domain of any
halt decider.

>
The definition of a halt decider requires that a halt decider
correctly predicts whether a direct execution halts

>
That has always been incorrect because no Turing machine
can ever take any directly executing Turing machine as
its input all of these directly executed Turing machines
are outside of the domain of any partial halt decider.

>
No, it is not incorrect. It is what the words mean.

>
Likewise with the definition of a circle as having four
equal length sides.

 The concept defined by that definition is good and well-defined but
the word "circle" is already reserved for another geometric concept
by earlier geometers. The usual meaning of "hating" in context of
Turing machines has no prior meaning because Turing machine is a
recent innovation and the meaning is compatible with the traditional
meaning of "halting" in Common Language. Therefore your "likewise"
is false.
 

The requirement that a halt decider
report on the behavior of the direct execution of a machine
is contradicted by the fact that no Turing Machine can take
a directly executing machine as its input.

 The requirement says "predicts", not reports, though both words
mean the same in this context.
 But "the requirement is not contradicted" is a category error.

When it is required that a Turing Machine halt decider is to
report on the behavior of another directly executing Turing
machine this requirement is incorrect.
This requirement is incorrect because Turing machines only
take finite string inputs they do not take directly executing
Turing Machines as inputs.
It usually makes no difference because almost all of the time
the finite string machine description serves as a proxy and
has the same behavior. Thus the correct simulation of this
input has the same behavior as the direct execution of this
input.
When an input calls is own decider then this does make a
difference. In this case the partial halt decider is required
to report on the behavior that its finite string actually
specifies instead of the directly executed behavior that
it cannot see.

A claim or proposition can be contradicted by another one but
the word "contradict" does not apply to requirements. A
requirement can be satisfied or violated but not contradicted.
If your algoritm does not satisfy the requirements of a halting
decider then it is not a halting decider.
 

Just because no one has ever noticed this before does not
mean that I am wrong.

 It doesn't mean that you be right, either. But other considerations
show that you are partly wrong and partly babbling.
 

Partial halt deciders are only held
accountable for *inputs* in their domain. Their own directly
executed selves are not *inputs* in their domain.

 If it does not satisfy all requirements of the halting problems
except of answering for every valid input then it is not a partial
halting decider.
 

Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
is correct because ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by
Ĥ.embedded_H cannot possibly reach its own simulated
final halt state ⟨Ĥ.qn⟩.

>
Correct or incorrect does not apply to Ĥ as there are no requirements.

>
The requirement is that Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
determine the halt status that its input specifies.

 Not required by Linz' proof or by anything in Linz' book.
 

*Here is the whole Linz proof*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

 

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