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

On 3/7/24 5:52 PM, olcott wrote:

On 3/7/2024 7:34 PM, immibis wrote:

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

 No matter how much Ĥ ⟨Ĥ⟩ can screw itself up it still must either
halt or fail to halt and H ⟨Ĥ⟩ ⟨Ĥ⟩ can see this.

Nope. Because if H tries to keep on simulating to find the answer, it might simulate forever and never get to give the answer.
If it stops before the H^.H makes its decision (as it must) then it doesn't know that H^ will do.
The problem is that since H^ is using the algorithm in H, it can know the answer that H will give and do the opposite (if H does stop to give an answer, and if it doesn't it has already failed).

 

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