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

On 2025-06-29 13:17:19 +0000, olcott said:

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.

No, it is not. There is no requirement that this requirement
would violate. A requirement is valid if one can determine
whether the requirement is violated. If an excution halts
that can be determined by a direct execution. If an execution
is non-halting that may be harder to determine but a partial
exeution with tracing and then examination of the algorithm
and the last steps of the trace provides information for
determination that the computation does not halt or at least
how much more should be traced for the determination. The
lack of a complete method can be compensated by human
creativity.

This requirement is incorrect because Turing machines only
take finite string inputs they do not take directly executing
Turing Machines as inputs.

That "because" is cannot be inferred with a truth preserving
transformatin, so it is false.

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.

A string has no behaviour. It contains information. In the case
of the halting problem it contains enough information about a
computation for an execution of the computation.
--
Mikko