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

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.