Re: How do we know that ChatGPT 4.0 correctly evaluated my ideas?

On 7/03/24 18:36, olcott wrote:

On 3/7/2024 9:50 AM, immibis wrote:

On 7/03/24 16:38, olcott wrote:

On 3/7/2024 5:44 AM, Mikko wrote:

On 2024-03-06 17:08:25 +0000, olcott said:
>

On 3/6/2024 3:06 AM, Mikko wrote:

On 2024-03-06 07:11:34 +0000, olcott said:
>

Chat GPT CAN'T understand the words, it has no programming about MEANING.

>
You cant find any mistakes in any of its reasoning.
>
*This paragraph precisely follows from its preceding dialogue*
>
When an input, such as the halting problem's pathological input D, is
designed to contradict every value that the halting decider H returns,
it creates a self-referential paradox that prevents H from providing a
consistent and correct response. In this context, D can be seen as
posing an incorrect question to H, as its contradictory nature
undermines the possibility of a meaningful and accurate answer.

>
That is essentially an agreement with Linz proof.

*It is not an agreement with the conclusion of this proof*

>
Not explicitly but comes close enough that the final step is
trivial.
>

It is an agreement with why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer.

>
That, too.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
The Linz proof correctly proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
can't possibly get the right answer and falsely
concludes that this means that H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot
get the correct answer.
>
*My H(D,D) and H1(D,D) prove otherwise*
>

>
An embedded copy of a machine is stipulated to always get the same result as the original machine.

 *Until one carefully examines the proof that this is false*
 

The details of the proof are specified for Turing machines. To make it work for Olcott machines, we have to change the details. But it still works.
Let's say H is the Olcott machine that's a halt decider. Make a new machine Ĥ by joining these parts:
1. A part that deletes the machine description from the tape.
2. A part that makes two copies of its input (<Ĥ> turns into <Ĥ> <Ĥ>)
3. A part that puts the machine description of H (NOT Ĥ) on the tape.
4. A copy of H. When it tries to read its own machine description, it reads the description of H, not the description of Ĥ, since step 3 put it there.
5. An infinite loop if the copy of H gets to the copy of the qy state.
Since the embedded copy of H reads the same input and machine description that a direct execution of H would read, and follows the same instructions, it gets to the same result. And that result is wrong. There is no way for H to act differently based on the fact it's embedded within Ĥ - changing the machine description makes sure that it has no way to know it's embedded.
Since an Olcott machine is just a Turing machine that accepts its own machine description on the tape, the copy of H isn't an Olcott machine, but it doesn't have to be one. It's a Turing machine that always gets the same answers as the Olcott machine H.