On 10/16/2025 4:21 AM, Mikko wrote:On 2025-10-15 12:30:12 +0000, olcott said:>
On 10/15/2025 4:15 AM, Mikko wrote:On 2025-10-15 02:17:50 +0000, olcott said:>
>5. In short>
>
The halting problem as usually formalized is syntactically
consistent only because it pretends that U(p) is well-defined for
every p.
The halting problem does not pretend anything about U(p). It does not
even mention U(p).
It semantically entails U(p)
A problem does not entail anything, semantically or otherwise.
The words "ptoblem" and "entail" are semantically incompatible.
It requires every decider H to report on the behavior
of UTM(p). When p calls H then the behavior of UTM(p)
is outside of the domain of H.
No, it does not. But a decider that does not answer as required
by the halting problem is not a nalting decider.
When in fact they are not, thus a break from reality.
That does not make sense. What "they" and what they are not?
The halting problem stipulates that they are in the
same domain. Correct semantic entailment proves that
they are not.
The halting problem does not stipulate. It asks for a method to
answer all questions that ask about a Turing machine and an
input that can be given to it whether the Turing machine halts.
HHH(DD)==0 and HHH1(DD)==1 proves this when the ultimate
measure of the behavior that the input specifies is
the simulation of its input by its decider according to
the semantics of its language.
No, it does not. It only proves that one of them gives the wrong
answer and the other the right one.
<Input to LLM systems>
Please think this all the way through without making any guesses
>
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
(c) If HHH must abort its simulation to prevent its own non-termination
then HHH is correct to abort this simulation and return 0.
>
typedef int (*ptr)();
int HHH(ptr P);
>
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
>
int main()
{
HHH(DD);
}
>
What value should HHH(DD) correctly return?
</Input to LLM systems>
To know that, we must wait for HH(DD) to return a value.
That establishes the opposite value as the correct one.
Several weeks ago, it looked as if you finally understood this,
acknowledging that when some decider H0 wrongly decides a diagonal case
H0(D0), it is perfectly possible for another decider H1 that is not H0
to decide the case: H1(D0) can answer correctly by returning the
opposite value.
For instance, one way to construct H1 is this:
H1(P) {
return ! H0(P)
}
H1 asks H0 what the answer is, and then returns the negation. For the
case H1(D0), H1 calls H0(D0). then gets an answer which is wrong, and
returns the correct answer by inverting it.
H1 might not be useful, but it decides D0 correctly, no matter
how H0 is designed, provided that H0(D0) terminates.
The key element of my whole proof is the behavior
of the input to HHH(DD) within the semantics of the
C programming language.
The semantics of the C programming language is a really stupid
thing to introduce into formal CS work.
You obviously have no intution for what makes CS academia tick
and how to engage with it.
***
Just one mention of "C programming language semantics" in something
related to the halting problem, and you are instantly identified as an
idiot/crank.
That you cannot see this is a giant facepalm.
***
You really have no actual plan to take your "work" beyind Usenet
arguments, do you; that's just idle talk.
The LLM systems are smart enough to not conflate
"LLM systems are smart enough" --- How to say I'm a gullible idiot, on
top of being a crank, without literally saying "I'm a gullible idiot".
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
Les messages affichés proviennent d'usenet.