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

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.

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

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.
*The standard halting problem proof cannot even be constructed*
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
}

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:
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.
This proves that the input to HHH(DDD) specifies
a non-halting sequence of configutations.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer