Re: Claude.ai provides reasoning why I may have defeated the conventional HP proof

On 7/7/25 9:57 AM, olcott wrote:

On 7/7/2025 3:20 AM, Mikko wrote:

On 2025-07-06 14:48:45 +0000, olcott said:
>

On 7/6/2025 3:30 AM, Mikko wrote:

On 2025-07-05 15:18:46 +0000, olcott said:
>

On 7/5/2025 4:06 AM, Mikko wrote:

On 2025-07-04 20:16:34 +0000, olcott said:
>

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

>
Perhaps an artificial idiot can think better than you but it does
not think better than most participants of these discussions.

>
Yet you cannot point out any actual error.

>
There is no error in your above quoted words.
>

What is not provable is not analytic truth.

>

I totally agree. Not only must it be provable it must
be provable semantically not merely syntactically.

>
In order to prove anything a proof must be syntactically correct.
Then the conclusion is semantically true if the premises are.

>
Not exactly. Some of logic is wrong.

>
There is no example where ordinary logic derives a false conclusion from
true premises. Other logics may contain mistakes so they should not be
used unless proven valid.
>

 The one that I have in mind derives a true conclusion
from false premises.

Which is just an unsound argument that just happens to reach a correct solution.

 

An analytic proof requires a semantic connection
from a set of expressions of language that are
stipulated to be true.

>
It requires a syntactic connection. A semantic connection can always
be expressed with a syntactic connection. Other ways of expression
tend to lead to errors.
>

 It can be a semantics connection express syntactically.
Unless all of the relevant semantics are included terrible
mistakes are made. For example type mismatch errors.

NO, in Formal Logic, *ALL* semantics can be expressed syntactically.

 

I used C and x86 as my proof
languages.

>
They cannot be used as proof languages as they don't have any concept of inference. In addition, they don't have any reasonable interrpetation as
truth-bearer languages.
>

 The semantics of the x86 language specifies every single
detail of each state transition such that disagreement
is inherently incorrect.

Right, such as a call instuction will ALWAYS be followed by the instruction addressed by it, and any other result is an error.

 

Claude does provide the proof on the basis of understandings
that I provided to it.

>
Which are not acceptable premises for those reader who undrstand
the halting problem and related topics.
>

 *This definition has proven to be perfectly fine*
Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
 That people disagree with the result of that merely
proves that they have poor understanding of programming.
 

Here is the key new one:
>
Since no Turing machine can take another directly executing
Turing machine as an input they are outside of the domain
of any Turing machine based decider.

>
By the same reasning there are no universal Turing machines.

>
Counter-factual. UTMs are easy.

>
Indeed. If your reasoning were correct an universal Turing
machine would be impossible but there are universal Turing
machines so (by the inference rule known as modus tollens)
your reasoning is not correct.
>

 A UTM is one thing. A UTM that can watch the behavior
of its input detecting non-terminating patterns is
something else.

But if it stops before finishing the simulation, it isn't a UTM.
That is like saying that your street legal car is still street legal after removing the headlight and brakes.

 

But the reasoning is not correct. The halting problem requires
that a halt decider must predict what happens later ir the
descirbed comutation is performed.

>
That is an incorrect requirement.

>
A requirement is correct if it is possible to determine whether
it is satisfied. If the prediction is "does not halt" and a
direct execution halts then the requirement is

 proven to be incorrect. Halt deciders have never actually
been required to report on elements outside of their domain
of TMs encoded as finite strings. When textbooks say otherwise
they are wrong. Because you only learn these things by rote
memorization and have no actual depth of understanding you may
never get this.

And their domain include finite strings that encode Turing Machines, from which the full behavior of that machine is defined, and thus that behavior is subject to being asked for.

 

not met and the
predicting machien is not a halt decider, because that is what
the words mean.
>

 Predicting the behavior specified by their input.
Not predicting the behavior of things that are not
TMs encoded as finite strings.

So, you think UTMs don't exist? That Turing Machine can't be encoded as a finite string and have *ALL* of its behavior reconstructed from that finite string?
Then I guess you don't think simulation is possible, and thus simulators and Stimulating Halt Decider don't exist.
See all the problems your lies create, you just prove that you arguement is a lie.

 

Partial halt deciders can only report on the actual
behavior that their actual input actually specifies.

>
They cannot do even that for every possible behaviour. Some of
them can determine more cases than some others but none of them
can determine all cases.
>

 For the crucial counter-example input DD emulated by
HHH cannot possibly reach its own final halt state.

But DD correctly emuated does.
The fact that no Decider HHH can do a correct simulation means it can't be the source of defining non-halting.
Sorry, you world is just based on lies.

 

The requirement that a partial halt decider to report on the
behavior of a directly executed machine has always been bogus.

>
No, it is not:
>

 You already know that TMs can only take finite string
encodings of TMs. The directly executed machine is not
a finite string at all.

But can be encoded in one, as you just admitted.

 

The Wikipeda page https://en.wikipedia.org/wiki/Halting_problem confirms
what I said above. The magic word "bogus" has no effect, no matter how
may times you say it.

>

All of the halting problem proofs depend on an input
to a partial halt decider doing the opposite of whatever
the decider decides. No such input exists.

>
An analytic truth is that such input is constructible.
>

 Unless you try to actually do it and find that all such
cases do not involve actual inputs.

But it does, your problem is your arguement doesn't look at the actual input, but an altered version of it, as it looks while on a bad trip.

 

*The standard halting problem proof cannot even be constructed*

>
It has been constructed and published and checked and found good.
But the proof does not apply to your work because your work is
not about the halting problem.
>

 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
 When Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn it is correct.
The computation that Ĥ.embedded_H is contained within:
"Ĥ applied to ⟨Ĥ⟩" is not an actual input to Ĥ.embedded_H.
 

How? Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transitioning to Ĥ.qn means that H^ (H^) (H^) will never halt, but it does.
You are just showing you are just a stupid ignorant liar that doesn't know what he is talking about.