On 3/6/2024 7:47 PM, Richard Damon wrote:
> But ChatGPT "agreeing" to an incorrect statement doesn't make it true.

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.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

ChatGPT agreed that asking Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ whether or not its
input halts is proven to to an incorrect question for Ĥ.H.

When we merely substitute Ĥ.H for H and ⟨Ĥ⟩ ⟨Ĥ⟩ for D then
we can see that ChatGPT is correct.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/6/24 7:01 PM, olcott wrote:
> On 3/6/2024 7:47 PM, Richard Damon wrote:
>> But ChatGPT "agreeing" to an incorrect statement doesn't make it true.
>
> 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.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> ChatGPT agreed that asking Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ whether or not its
> input halts is proven to to an incorrect question for Ĥ.H.
>
> When we merely substitute Ĥ.H for H and ⟨Ĥ⟩ ⟨Ĥ⟩ for D then
> we can see that ChatGPT is correct.
>
>

And you still haven't answer why CHAT GPT agreeing with you means anything.

It just shows you were able to fool it into parroting back your errors.

You are still wrong, because you LIE about what you were doing.

On 3/6/24 6:31 PM, olcott wrote:
> On 3/6/2024 7:47 PM, Richard Damon wrote:
>> On 3/6/24 3:57 PM, olcott wrote:
>>> On 3/6/2024 5:49 PM, immibis wrote:
>>>> On 6/03/24 18:10, olcott wrote:
>>>>> On 3/6/2024 10:40 AM, immibis wrote:
>>>>>>
>>>>>> Richard gets it, but the fact that H and H1 do different things
>>>>>> means one is not a copy of the other. If you are saying they are
>>>>>> copies, that means they do the same thing.
>>>>>
>>>>> *Refutation of the Peter Linz Halting Problem proof*
>>>>>
>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>>
>>>> they always get the same answer because they are exactly identical
>>>> copies, dumbass. H and H1 are not exactly identical copies because
>>>> you did not follow the Linz procedure.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
>>> Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.
>>>
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>> Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation.
>>>
>>
>> Which is impossible
>
> It is not utterly impossible because you and I can both
> see that it is true.

What is impossible is for H and H^.H to give different answers and still
be the required compuation and its exact copy.

>
> What you mean by "impossible" is not Turing computable.
> This is not the same thing as utterly impossible.

IS IMPOSSIBLE to be a behavior of what you claim it is.

Of course, since you don't understand what computation is, this just
proves that you are

>
> Both Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ are correctly reporting on:
> Will you halt if you never abort your simulation?
>
> This has the side-effect that H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the
> actual behavior of Ĥ ⟨Ĥ⟩.
>

And neither is a Computation of the required inputs, and thus can't be a
decider, and you are proven to be just an ignorant pathological lying idiot.

On 3/6/2024 10:16 PM, Richard Damon wrote:
> On 3/6/24 7:01 PM, olcott wrote:
>> On 3/6/2024 7:47 PM, Richard Damon wrote:
>>> But ChatGPT "agreeing" to an incorrect statement doesn't make it true.
>>
>> 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.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> ChatGPT agreed that asking Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ whether or not its
>> input halts is proven to to an incorrect question for Ĥ.H.
>>
>> When we merely substitute Ĥ.H for H and ⟨Ĥ⟩ ⟨Ĥ⟩ for D then
>> we can see that ChatGPT is correct.
>>
>>
>
>
> And you still haven't answer why CHAT GPT agreeing with you means anything.
>
> It just shows you were able to fool it into parroting back your errors.
>
> You are still wrong, because you LIE about what you were doing.

If you don't trust a calculator to do a certain arithmetic
problem then you do it manually by yourself and then check
its results. When they check out then you are logically
certain that this calculator did perform this arithmetic
problem correctly.

The precise meaning of the words that ChatGPT generated
100% exactly corresponds to the ordinary meaning of all
of the words except "incorrect question" that is a brand
new idea thus has no ordinary definition.

ChatGPT even explains the correct meaning of my term:
{incorrect question}.

ChatGPT is very obviously totally correct when you
swap Ĥ.H for its H and ⟨Ĥ⟩ ⟨Ĥ⟩ for its D.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/6/24 8:54 PM, olcott wrote:
> On 3/6/2024 10:16 PM, Richard Damon wrote:
>> On 3/6/24 7:01 PM, olcott wrote:
>>> On 3/6/2024 7:47 PM, Richard Damon wrote:
>>>> But ChatGPT "agreeing" to an incorrect statement doesn't make it true.
>>>
>>> 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.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> ChatGPT agreed that asking Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ whether or not its
>>> input halts is proven to to an incorrect question for Ĥ.H.
>>>
>>> When we merely substitute Ĥ.H for H and ⟨Ĥ⟩ ⟨Ĥ⟩ for D then
>>> we can see that ChatGPT is correct.
>>>
>>>
>>
>>
>> And you still haven't answer why CHAT GPT agreeing with you means
>> anything.
>>
>> It just shows you were able to fool it into parroting back your errors.
>>
>> You are still wrong, because you LIE about what you were doing.
>
> If you don't trust a calculator to do a certain arithmetic
> problem then you do it manually by yourself and then check
> its results. When they check out then you are logically
> certain that this calculator did perform this arithmetic
> problem correctly.

And the calculator doesn't understand what it is doing and gives you the
mechanical answer.

If you start with wrong numbers, you will still get the wrong answer.

>
> The precise meaning of the words that ChatGPT generated
> 100% exactly corresponds to the ordinary meaning of all
> of the words except "incorrect question" that is a brand
> new idea thus has no ordinary definition.
>
> ChatGPT even explains the correct meaning of my term:
> {incorrect question}.
>
> ChatGPT is very obviously totally correct when you
> swap Ĥ.H for its H and ⟨Ĥ⟩ ⟨Ĥ⟩ for its D.
>

So, you are just showing that you don't understand what you are talking
aobut and how logic works.

Go ahead, prove yourself to be the idiot that thinks a LLM actually can
prove that something is true.

On 3/6/2024 10:18 PM, Richard Damon wrote:
> On 3/6/24 6:31 PM, olcott wrote:
>> On 3/6/2024 7:47 PM, Richard Damon wrote:
>>> On 3/6/24 3:57 PM, olcott wrote:
>>>> On 3/6/2024 5:49 PM, immibis wrote:
>>>>> On 6/03/24 18:10, olcott wrote:
>>>>>> On 3/6/2024 10:40 AM, immibis wrote:
>>>>>>>
>>>>>>> Richard gets it, but the fact that H and H1 do different things
>>>>>>> means one is not a copy of the other. If you are saying they are
>>>>>>> copies, that means they do the same thing.
>>>>>>
>>>>>> *Refutation of the Peter Linz Halting Problem proof*
>>>>>>
>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>>>
>>>>> they always get the same answer because they are exactly identical
>>>>> copies, dumbass. H and H1 are not exactly identical copies because
>>>>> you did not follow the Linz procedure.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
>>>> Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.
>>>>
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>> Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation.
>>>>
>>>
>>> Which is impossible
>>
>> It is not utterly impossible because you and I can both
>> see that it is true.
>
> What is impossible is for H and H^.H to give different answers and still
> be the required compuation and its exact copy.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

The design of Olcott Machines makes quite easy for Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
to get its abort criteria.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/6/24 10:19 PM, olcott wrote:
> On 3/6/2024 10:18 PM, Richard Damon wrote:
>> On 3/6/24 6:31 PM, olcott wrote:
>>> On 3/6/2024 7:47 PM, Richard Damon wrote:
>>>> On 3/6/24 3:57 PM, olcott wrote:
>>>>> On 3/6/2024 5:49 PM, immibis wrote:
>>>>>> On 6/03/24 18:10, olcott wrote:
>>>>>>> On 3/6/2024 10:40 AM, immibis wrote:
>>>>>>>>
>>>>>>>> Richard gets it, but the fact that H and H1 do different things
>>>>>>>> means one is not a copy of the other. If you are saying they are
>>>>>>>> copies, that means they do the same thing.
>>>>>>>
>>>>>>> *Refutation of the Peter Linz Halting Problem proof*
>>>>>>>
>>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>>>>
>>>>>> they always get the same answer because they are exactly identical
>>>>>> copies, dumbass. H and H1 are not exactly identical copies because
>>>>>> you did not follow the Linz procedure.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
>>>>> Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.
>>>>>
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>> Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation.
>>>>>
>>>>
>>>> Which is impossible
>>>
>>> It is not utterly impossible because you and I can both
>>> see that it is true.
>>
>> What is impossible is for H and H^.H to give different answers and
>> still be the required compuation and its exact copy.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> The design of Olcott Machines makes quite easy for Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> to get its abort criteria.
>
>

Which isn't the Halting Criteria, so it gets the wrong answer to the
Halting Problem.

And you are proved to be a LIAR, since you are claiming to be working on
the Halting Problem, but are knowing using the wrong definitions.

On 3/7/2024 12:35 AM, Richard Damon wrote:
> On 3/6/24 10:19 PM, olcott wrote:
>> On 3/6/2024 10:18 PM, Richard Damon wrote:
>>> On 3/6/24 6:31 PM, olcott wrote:
>>>> On 3/6/2024 7:47 PM, Richard Damon wrote:
>>>>> On 3/6/24 3:57 PM, olcott wrote:
>>>>>> On 3/6/2024 5:49 PM, immibis wrote:
>>>>>>> On 6/03/24 18:10, olcott wrote:
>>>>>>>> On 3/6/2024 10:40 AM, immibis wrote:
>>>>>>>>>
>>>>>>>>> Richard gets it, but the fact that H and H1 do different things
>>>>>>>>> means one is not a copy of the other. If you are saying they
>>>>>>>>> are copies, that means they do the same thing.
>>>>>>>>
>>>>>>>> *Refutation of the Peter Linz Halting Problem proof*
>>>>>>>>
>>>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>>>>>
>>>>>>> they always get the same answer because they are exactly
>>>>>>> identical copies, dumbass. H and H1 are not exactly identical
>>>>>>> copies because you did not follow the Linz procedure.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
>>>>>> Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.
>>>>>>
>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>> Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation.
>>>>>>
>>>>>
>>>>> Which is impossible
>>>>
>>>> It is not utterly impossible because you and I can both
>>>> see that it is true.
>>>
>>> What is impossible is for H and H^.H to give different answers and
>>> still be the required compuation and its exact copy.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> The design of Olcott Machines makes quite easy for Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>> to get its abort criteria.
>>
>>
>
> Which isn't the Halting Criteria, so it gets the wrong answer to the
> Halting Problem.
>

The "abort criteria" cause the correct halt status
to be derived indirectly.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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.

--
Mikko

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*

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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. If this is not true, then you did not
make an embedded copy. Making an embedded copy of a Turing machine is
straightforward. Making an embedded copy of an Olcott machine is a bit
more tricky - you have to make sure that whenever the original accesses
"my own description", the embedded copy includes a copy of whatever that
description would be for the original machine, and accesses that instead.

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*

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/7/24 7: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. If this is not true, then you did not
> make an embedded copy. Making an embedded copy of a Turing machine is
> straightforward. Making an embedded copy of an Olcott machine is a bit
> more tricky - you have to make sure that whenever the original accesses
> "my own description", the embedded copy includes a copy of whatever that
> description would be for the original machine, and accesses that instead.

That an "Identical Copy" of a Computation will get the same answer isn't
a "Stipulation" but a provable fact from the definitions. The
stipulations are in what a Computation, Algorithm, and exact copy are
defined to be.

On 3/7/24 7:38 AM, 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*
>

Nopd, because all you do is prove that your H1 is not computing the same
computation as H, because neither is actual a computation as described,
but have a hidden input, that makes H1 compute a different function than
H and thus isn't "An H that got the answer right".

You are just proving your total stupidity in the topic, and that you
just don't even understand how logic works.

You are showing that you are just a self-made, ignorant, hypocritcal,
pathological lying idiot.

On 3/6/24 11:14 PM, olcott wrote:
> On 3/7/2024 12:35 AM, Richard Damon wrote:
>> On 3/6/24 10:19 PM, olcott wrote:
>>> On 3/6/2024 10:18 PM, Richard Damon wrote:
>>>> On 3/6/24 6:31 PM, olcott wrote:
>>>>> On 3/6/2024 7:47 PM, Richard Damon wrote:
>>>>>> On 3/6/24 3:57 PM, olcott wrote:
>>>>>>> On 3/6/2024 5:49 PM, immibis wrote:
>>>>>>>> On 6/03/24 18:10, olcott wrote:
>>>>>>>>> On 3/6/2024 10:40 AM, immibis wrote:
>>>>>>>>>>
>>>>>>>>>> Richard gets it, but the fact that H and H1 do different
>>>>>>>>>> things means one is not a copy of the other. If you are saying
>>>>>>>>>> they are copies, that means they do the same thing.
>>>>>>>>>
>>>>>>>>> *Refutation of the Peter Linz Halting Problem proof*
>>>>>>>>>
>>>>>>>>> The following shows how Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right
>>>>>>>>> answer because Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer
>>>>>>>>
>>>>>>>> they always get the same answer because they are exactly
>>>>>>>> identical copies, dumbass. H and H1 are not exactly identical
>>>>>>>> copies because you did not follow the Linz procedure.
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>>
>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
>>>>>>> Correctly reports that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation.
>>>>>>>
>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>> Correctly reports that H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation.
>>>>>>>
>>>>>>
>>>>>> Which is impossible
>>>>>
>>>>> It is not utterly impossible because you and I can both
>>>>> see that it is true.
>>>>
>>>> What is impossible is for H and H^.H to give different answers and
>>>> still be the required compuation and its exact copy.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> The design of Olcott Machines makes quite easy for Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> to get its abort criteria.
>>>
>>>
>>
>> Which isn't the Halting Criteria, so it gets the wrong answer to the
>> Halting Problem.
>>
>
> The "abort criteria" cause the correct halt status
> to be derived indirectly.
>

Nope, proven by the fact that you say H(H^,H^) is correct in saying No
whien H^(H^) Halts.

So, you ard just shown to be an ignorant blantant liar.

Can't even claim honest mistake here, as this has been clearly pointed
before, but you still insist that a wrong answer must be right.

On 3/7/24 9:36 AM, olcott wrote:
> On 3/7/2024 9:50 AM, immibis wrote:

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

Really, where is your counter proof?

I have asked for it several times, and your failure to provide it just
proves you know you are lying.

That seems to be your modus operandi, make a false claim about
something, saying it "Must" be true, and from that lie, prove your other
lies.

Your whole world view seems to be built on lie upon lie. That might
explain why you think you are "God" and it is ok to have illegal kiddie
porn.

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.

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.

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

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 8/03/24 02:52, 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.

you didn't read the rest

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

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

On 3/7/2024 8:10 PM, Richard Damon wrote:
> 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).

An Olcott machine H (exact same TMD as the Turing machine H)
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can trivially determine that *IT IS NOT* calling
itself in recursion simulation.

An Olcott machine Ĥ (exact same TMD as the Turing machine Ĥ)
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> can trivially determine that *IT IS* calling
itself in recursion simulation.

Turing machines cannot possibly do that because they inherently
have no self-awareness.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/7/24 7:18 PM, olcott wrote:
> On 3/7/2024 8:10 PM, Richard Damon wrote:
>> 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).
>
> An Olcott machine H (exact same TMD as the Turing machine H)
> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can trivially determine that *IT IS NOT* calling
> itself in recursion simulation.
>
> An Olcott machine Ĥ (exact same TMD as the Turing machine Ĥ)
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> can trivially determine that *IT IS* calling
> itself in recursion simulation.

First, the H^ for Olcott machines will be DIFFERENT then the H^ for
Turing Machines due to your semantic differences in the machines.

That is allowed, because the purpose of H^ is to show that an input can
be created that confounds the decider, and that confounding is based on
a simple semantic principle which will be implemented differently for
different models of computation.

That principle is: Using an exact copy of the decider we are to
confound, called in exactly the inputs as the decider will be used with,
find out what the decider will decide for use and do the opposite.

This means the front end will change depending on the rules of how
machines are used and get their inputs.

And the back end will change depending on how machines give their answer,

So the copy of H at H^.H, since with Computations, the algorithms can
only depend on the actual inputs, can be given the exact same input as
the top level H gets.

Remember, the rest of H^ is antagonistic to H, and is working to prove
it wrong, so you can't try to say that it COULD detect the condition,
because it isn't designed to do that.

H^ isn't designed to "Get the right answer", it is designed to make H
get the WRONG answer.

>
> Turing machines cannot possibly do that because they inherently
> have no self-awareness.
>

Right, ALL computation engines are "mechanical" in operation, having a
fixed set of instructions that do exactly as they are programmed to do.
And that includes your H, even as a Olcott-Machine.