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

On 7/6/25 10:48 AM, olcott wrote:

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.
An analytic proof requires a semantic connection
from a set of expressions of language that are
stipulated to be true. I used C and x86 as my proof
languages.

But they are NOT "Proof Languages", so you are just admitting you don't know what you are doing.

 

Claude does provide the proof on the basis of understandings
that I provided to it. 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.

But impossible by your reasoning, after all, NO Turing Machine can be responsible for the behavior of a directly executed Turing Machine, but that is EXACTLY the responsibility of a UTM.

 

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.
Partial halt deciders can only report on the actual
behavior that their actual input actually specifies.

But the *ACTUAL BEHAVIOR* is BY DEFINITION, the behavior of the direct execution of the machine the input represent, or the actual simulation of the input by an actual UTM (which means it can't abort part way throgh).
Since the "input" DDD does halt for both of these, your HHH is just incorrect about it.

 

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

>
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.

Sure it does.

 *The standard halting problem proof cannot even be constructed*

Then what is DD?
I guess you are just showing your dementia.

 int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
 int main()
{
   HHH(DD); // DD cannot do the opposite of HHH
   DD();    // The caller of HHH(DD) is not its input
}

But that isn't what it needs to do.
It needs to do the opposite of what the ANSWER from HHH says it would do.
Which it does.

 

Opinions of artificial
idiots are not relevant. You have not proven any of your claims.

>
Your claims remain unproven as long as you don't prove them. You may
ask an AI to show a rigorous proof but ultimately its up to you to
prove or fail to prove your claims.
>

 Since all four ai bots independently derive the essence
of my reasoning on their own this disavows all of the
gaslighting to the contrary:

And all four were feed the same lie, so all you are doing is proving your natural stupidity in not understand how artificial intelegence works.

 typedef void (*ptr)();
int HHH(ptr P);
 void DDD()
{
   HHH(DDD);
   return;
}
 int main()
{
   HHH(DDD);
}
 DDD simlated by HHH according to the semantics of
the C programming language cannot possibly reach its
own simulated "return" statement final halt state.
 

But HHH doesn't do a correct simultioin (as HHH is ONLY the one you have defined in Halt7.c) and that does abort, so your statement is must a fantasy, as it seems most of your world.

This proves that the input to HHH(DDD) specifies
a non-halting sequence of configutations.
 

Nope, it proves you are just a stupid liar, that doesn't understand logic, and keeps on believing your own lies because you are too stupid to understand the truth,