Re: Four Chatbots figure out on their own without prompting that HHH(DDD)==0

On 7/19/2025 3:14 PM, wij wrote:

On Sat, 2025-07-19 at 15:01 -0500, olcott wrote:

On 7/19/2025 2:59 PM, wij wrote:

On Sat, 2025-07-19 at 14:47 -0500, olcott wrote:

On 7/19/2025 2:29 PM, wij wrote:

On Sat, 2025-07-19 at 14:19 -0500, olcott wrote:

On 7/19/2025 12:02 PM, Richard Damon wrote:

On 7/19/25 10:42 AM, olcott wrote:

On 7/18/2025 3:49 AM, joes wrote:
>

That is wrong. It is, as you say, very obvious that HHH cannot simulate
DDD past the call to HHH. You just draw the wrong conclusion from it.
(Aside: what "seems" to you will convince no one. You can just call
everybody dishonest. Also, they are not "your reviewers".)
>

>
For the purposes of this discussion this is the
100% complete definition of HHH. It is the exact
same one that I give to all the chat bots.
>
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.

>
So, the only HHH that meets your definition is the HHH that never
detects the pattern and aborts, and thus never returns.
>

>
All of the Chat bots conclude that HHH(DDD) is correct
to reject its input as non-halting because this input
specified recursive simulation. They figure this out
on their own without any prompting.
>
https://chatgpt.com/share/687aa4c2-b814-8011-9e7d-b85c03b291eb

>
It is still nothing to do with the Halting Problem proof (Because it is POOH)
>

>
It is a key element of my refutation of this proof
because HHH also correctly determines that HHH(DD)==0.
>
DD correctly simulated by HHH cannot possibly ever
reach past its first statement because it specifies
recursive simulation.
>
int DD()
{
     int Halt_Status = HHH(DD);
     if (Halt_Status)
       HERE: goto HERE;
     return Halt_Status;
}
>

>
Boring. HHH cannot do what the HP says.
>

>
Turing machine (at least partial) halt deciders only compute
the mapping from their finite string inputs to the actual
behavior that this input finite string actually specifies.
>
Conventional notation of a Turing Machine: Ĥ
Conventional notation of a TM description: ⟨Ĥ⟩
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
    if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    if Ĥ applied to ⟨Ĥ⟩ does not halt.
>
*Is corrected to this*
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
      ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
      its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
      ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
      reach its simulated final halt state of ⟨Ĥ.qn⟩.
>
*Original proof*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

 https://en.wikipedia.org/wiki/Halting_problem
https://brilliant.org/wiki/halting-problem/
https://www.geeksforgeeks.org/theory-of-computation/halting-problem-in-theory-of-computation/
https://www.sciencedirect.com/science/article/pii/S235222082100050X
 Modifying historical fact is nut.
 HP is very simple: H(D)=1 if D halts, H(D)=0 if D does not halt.
 

The standard proof assumes a decider
H(M,x) that determines whether machine
M halts on input x.
But this formulation is flawed, because:
Turing machines can only process finite encodings
(e.g. ⟨M⟩), not executable entities like M.
So the valid formulation must be
H(⟨M⟩,x), where ⟨M⟩ is a string.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer