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