When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // wrong answer

The above pair of templates specify every encoding of Ĥ that can
possibly exist, an infinite set of Turing machines such that each one
gets the wrong answer when it is required to report its own halt status.
https://www.liarparadox.org/Linz_Proof.pdf

This proves that the halting problem counter-example
<is> isomorphic to the Liar Paradox.

--
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-02-08 14:14:55 +0000, olcott said:

> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // wrong answer
>
> The above pair of templates specify every encoding of Ĥ that can
> possibly exist, an infinite set of Turing machines such that each one
> gets the wrong answer when it is required to report its own halt status.
> https://www.liarparadox.org/Linz_Proof.pdf
>
> This proves that the halting problem counter-example
> <is> isomorphic to the Liar Paradox.

Ĥ is not required to report anything. Linz only specifies how Ĥ is
constructed but not what it should do.

--
Mikko

On 2/8/2024 8:33 AM, Mikko wrote:
> On 2024-02-08 14:14:55 +0000, olcott said:
>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>
>> The above pair of templates specify every encoding of Ĥ that can
>> possibly exist, an infinite set of Turing machines such that each one
>> gets the wrong answer when it is required to report its own halt status.
>> https://www.liarparadox.org/Linz_Proof.pdf
>>
>> This proves that the halting problem counter-example
>> <is> isomorphic to the Liar Paradox.
>
> Ĥ is not required to report anything. Linz only specifies how Ĥ is
> constructed but not what it should do.
>

*Clearly you didn't read what he said on the link*

--
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-02-08 14:39:05 +0000, olcott said:

> On 2/8/2024 8:33 AM, Mikko wrote:
>> On 2024-02-08 14:14:55 +0000, olcott said:
>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>
>>> The above pair of templates specify every encoding of Ĥ that can
>>> possibly exist, an infinite set of Turing machines such that each one
>>> gets the wrong answer when it is required to report its own halt status.
>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>
>>> This proves that the halting problem counter-example
>>> <is> isomorphic to the Liar Paradox.
>>
>> Ĥ is not required to report anything. Linz only specifies how Ĥ is
>> constructed but not what it should do.
>>
>
> *Clearly you didn't read what he said on the link*

The point is not what he said but what he didn't say. He didn't
say what Ĥ is required to do.

--
Mikko

On 2/8/2024 9:11 AM, Mikko wrote:
> On 2024-02-08 14:39:05 +0000, olcott said:
>
>> On 2/8/2024 8:33 AM, Mikko wrote:
>>> On 2024-02-08 14:14:55 +0000, olcott said:
>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>
>>>> The above pair of templates specify every encoding of Ĥ that can
>>>> possibly exist, an infinite set of Turing machines such that each one
>>>> gets the wrong answer when it is required to report its own halt
>>>> status.
>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>
>>>> This proves that the halting problem counter-example
>>>> <is> isomorphic to the Liar Paradox.
>>>
>>> Ĥ is not required to report anything. Linz only specifies how Ĥ is
>>> constructed but not what it should do.
>>>
>>
>> *Clearly you didn't read what he said on the link*
>
> The point is not what he said but what he didn't say. He didn't
> say what Ĥ is required to do.
>

He did say what Ĥ is required to do
and you simply didn't read what he said.

--
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/02/24 15:14, olcott wrote:
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>
> The above pair of templates specify every encoding of Ĥ that can
> possibly exist, an infinite set of Turing machines such that each one
> gets the wrong answer when it is required to report its own halt status.

This proves that it is impossible to for any Ĥ to give the right answer
on all inputs.

On 2/8/2024 10:32 AM, immibis wrote:
> On 8/02/24 15:14, olcott wrote:
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>
>> The above pair of templates specify every encoding of Ĥ that can
>> possibly exist, an infinite set of Turing machines such that each one
>> gets the wrong answer when it is required to report its own halt status.
>
> This proves that it is impossible to for any Ĥ to give the right answer
> on all inputs.

It proves that asking Ĥ whether it halts or not is an incorrect
question where both yes and no are the wrong answer.

--
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/02/24 19:09, olcott wrote:
> On 2/8/2024 10:32 AM, immibis wrote:
>> On 8/02/24 15:14, olcott wrote:
>>> When Ĥ is applied to ⟨Ĥ⟩
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>
>>> The above pair of templates specify every encoding of Ĥ that can
>>> possibly exist, an infinite set of Turing machines such that each one
>>> gets the wrong answer when it is required to report its own halt status.
>>
>> This proves that it is impossible to for any Ĥ to give the right
>> answer on all inputs.
>
> It proves that asking Ĥ whether it halts or not is an incorrect
> question where both yes and no are the wrong answer.

No, it proves the right answer is the opposite of what it says.

On 2/8/2024 12:15 PM, immibis wrote:
> On 8/02/24 19:09, olcott wrote:
>> On 2/8/2024 10:32 AM, immibis wrote:
>>> On 8/02/24 15:14, olcott wrote:
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>
>>>> The above pair of templates specify every encoding of Ĥ that can
>>>> possibly exist, an infinite set of Turing machines such that each one
>>>> gets the wrong answer when it is required to report its own halt
>>>> status.
>>>
>>> This proves that it is impossible to for any Ĥ to give the right
>>> answer on all inputs.
>>
>> It proves that asking Ĥ whether it halts or not is an incorrect
>> question where both yes and no are the wrong answer.
>
> No, it proves the right answer is the opposite of what it says.
>

*This seems to be over your head*
A self-contradictory question never has any correct answer.

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

On 2/8/24 9:14 AM, olcott wrote:
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>
> The above pair of templates specify every encoding of Ĥ that can
> possibly exist, an infinite set of Turing machines such that each one
> gets the wrong answer when it is required to report its own halt status.
> https://www.liarparadox.org/Linz_Proof.pdf
>
> This proves that the halting problem counter-example
> <is> isomorphic to the Liar Paradox.
>

In other words, you don't understand a thing about the problem.

It isn't talking about TEMPLATES, but programs, SPECIFIC instances of
those templages.

And Ĥ isn't being asked to decide anything, only H (and its copy
embedded_H).

To be a "Halt Decider", H (and its copy embedded_H) must be a specific
prgram that gives a particular answer to every input it is given.

Thus H (Ĥ) (Ĥ), and embedded_H (Ĥ) (Ĥ) has a defined answer before we
even start to look at the problem.

The fact that if this specific H (Ĥ) (Ĥ) goes to H.qn, thinking its
input is non-halting means that Ĥ (Ĥ) (the Computation described by H's
input) Halts because its embedded_H (Ĥ) (Ĥ) will also go to H.qn which
is the equivalent state to Ĥ.qn, and thus Ĥ halts, just means that H was
wrong.

A CORRECT Halt Decider HH (Ĥ) (Ĥ) will go to HH.qy and be correct, so
there is a corret answer to the question, does the computation described
by the input halt.

So, you are just proving that you argument is isomorphic to a LIE.

And, your "proof" just shows that it is impossible to make an H that
gives the right answer, proving what you are trying to disprove.

On 2/8/24 1:28 PM, olcott wrote:
> On 2/8/2024 12:15 PM, immibis wrote:
>> On 8/02/24 19:09, olcott wrote:
>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>> On 8/02/24 15:14, olcott wrote:
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>
>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>> possibly exist, an infinite set of Turing machines such that each one
>>>>> gets the wrong answer when it is required to report its own halt
>>>>> status.
>>>>
>>>> This proves that it is impossible to for any Ĥ to give the right
>>>> answer on all inputs.
>>>
>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>> question where both yes and no are the wrong answer.
>>
>> No, it proves the right answer is the opposite of what it says.
>>
>
> *This seems to be over your head*
> A self-contradictory question never has any correct answer.
>

So the Halting Question, does the computation described by the input
Halt? isn't a self-contradictory question, as it always has a correct
answer, the opposite of what H gives (if it gives one).

Thus, your premise is false.

On 2/8/2024 5:50 PM, Richard Damon wrote:
> On 2/8/24 1:28 PM, olcott wrote:
>> On 2/8/2024 12:15 PM, immibis wrote:
>>> On 8/02/24 19:09, olcott wrote:
>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>
>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>> possibly exist, an infinite set of Turing machines such that each one
>>>>>> gets the wrong answer when it is required to report its own halt
>>>>>> status.
>>>>>
>>>>> This proves that it is impossible to for any Ĥ to give the right
>>>>> answer on all inputs.
>>>>
>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>> question where both yes and no are the wrong answer.
>>>
>>> No, it proves the right answer is the opposite of what it says.
>>>
>>
>> *This seems to be over your head*
>> A self-contradictory question never has any correct answer.
>>
>
> So the Halting Question, does the computation described by the input
> Halt? isn't a self-contradictory question, as it always has a correct
> answer, the opposite of what H gives (if it gives one).
>
> Thus, your premise is false.

Maybe you need to carefully reread this fifty to sixty times before you
get it? (it took me twenty years to get it this simple)

When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the wrong
answer for every possible Ĥ applied to ⟨Ĥ⟩.

Do you understand that every possible element of an infinite set is more
than one element?

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

On 2/8/24 7:48 PM, olcott wrote:
> On 2/8/2024 5:50 PM, Richard Damon wrote:
>> On 2/8/24 1:28 PM, olcott wrote:
>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>> On 8/02/24 19:09, olcott wrote:
>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>
>>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>>> possibly exist, an infinite set of Turing machines such that each
>>>>>>> one
>>>>>>> gets the wrong answer when it is required to report its own halt
>>>>>>> status.
>>>>>>
>>>>>> This proves that it is impossible to for any Ĥ to give the right
>>>>>> answer on all inputs.
>>>>>
>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>> question where both yes and no are the wrong answer.
>>>>
>>>> No, it proves the right answer is the opposite of what it says.
>>>>
>>>
>>> *This seems to be over your head*
>>> A self-contradictory question never has any correct answer.
>>>
>>
>> So the Halting Question, does the computation described by the input
>> Halt? isn't a self-contradictory question, as it always has a correct
>> answer, the opposite of what H gives (if it gives one).
>>
>> Thus, your premise is false.
>
> Maybe you need to carefully reread this fifty to sixty times before you
> get it? (it took me twenty years to get it this simple)
>
> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the wrong
> answer for every possible Ĥ applied to ⟨Ĥ⟩.

But Ĥ doesn't need to report on anything, the copy of H that is in it does.

>
> Do you understand that every possible element of an infinite set is more
> than one element?
>

Right, so the set isn't a specific input, so not the thing that Halting
quesiton is about.

The Haltig problem is about making a decider that answers the Halting
QUestion which asks the decider about the SPECIFIC COMPUTATION (a
specific program/data) that the input describes.

Not about "sets" of Decider / Inputs

You are just talking POOP, not Halting Problem.

On 2/8/2024 8:40 PM, Richard Damon wrote:
> On 2/8/24 7:48 PM, olcott wrote:
>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>> On 2/8/24 1:28 PM, olcott wrote:
>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>
>>>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>>>> possibly exist, an infinite set of Turing machines such that
>>>>>>>> each one
>>>>>>>> gets the wrong answer when it is required to report its own halt
>>>>>>>> status.
>>>>>>>
>>>>>>> This proves that it is impossible to for any Ĥ to give the right
>>>>>>> answer on all inputs.
>>>>>>
>>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>>> question where both yes and no are the wrong answer.
>>>>>
>>>>> No, it proves the right answer is the opposite of what it says.
>>>>>
>>>>
>>>> *This seems to be over your head*
>>>> A self-contradictory question never has any correct answer.
>>>>
>>>
>>> So the Halting Question, does the computation described by the input
>>> Halt? isn't a self-contradictory question, as it always has a correct
>>> answer, the opposite of what H gives (if it gives one).
>>>
>>> Thus, your premise is false.
>>
>> Maybe you need to carefully reread this fifty to sixty times before
>> you get it? (it took me twenty years to get it this simple)
>>
>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the
>> wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>
>
> But Ĥ doesn't need to report on anything, the copy of H that is in it does.
>
>>
>> Do you understand that every possible element of an infinite set is
>> more than one element?
>>
>
> Right, so the set isn't a specific input, so not the thing that Halting
> quesiton is about.
>
> The Haltig problem is about making a decider that answers the Halting
> QUestion which asks the decider about the SPECIFIC COMPUTATION (a
> specific program/data) that the input describes.
>
> Not about "sets" of Decider / Inputs
>

When an infinite set of decider/input pairs has no correct
answer then the question is rigged.

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

On 2/8/24 10:34 PM, olcott wrote:
> On 2/8/2024 8:40 PM, Richard Damon wrote:
>> On 2/8/24 7:48 PM, olcott wrote:
>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>
>>>>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>>>>> possibly exist, an infinite set of Turing machines such that
>>>>>>>>> each one
>>>>>>>>> gets the wrong answer when it is required to report its own
>>>>>>>>> halt status.
>>>>>>>>
>>>>>>>> This proves that it is impossible to for any Ĥ to give the right
>>>>>>>> answer on all inputs.
>>>>>>>
>>>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>>>> question where both yes and no are the wrong answer.
>>>>>>
>>>>>> No, it proves the right answer is the opposite of what it says.
>>>>>>
>>>>>
>>>>> *This seems to be over your head*
>>>>> A self-contradictory question never has any correct answer.
>>>>>
>>>>
>>>> So the Halting Question, does the computation described by the input
>>>> Halt? isn't a self-contradictory question, as it always has a
>>>> correct answer, the opposite of what H gives (if it gives one).
>>>>
>>>> Thus, your premise is false.
>>>
>>> Maybe you need to carefully reread this fifty to sixty times before
>>> you get it? (it took me twenty years to get it this simple)
>>>
>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the
>>> wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>
>>
>> But Ĥ doesn't need to report on anything, the copy of H that is in it
>> does.
>>
>>>
>>> Do you understand that every possible element of an infinite set is
>>> more than one element?
>>>
>>
>> Right, so the set isn't a specific input, so not the thing that
>> Halting quesiton is about.
>>
>> The Haltig problem is about making a decider that answers the Halting
>> QUestion which asks the decider about the SPECIFIC COMPUTATION (a
>> specific program/data) that the input describes.
>>
>> Not about "sets" of Decider / Inputs
>>
>
> When an infinite set of decider/input pairs has no correct
> answer then the question is rigged.
>

Except that EVERY element of that set had a correct answer, just not the
one the decider gave.

You don't know the difference between a "correct" question, and an
uncomputable problem.

The fact that every input has a correct answer for the Halting Question
(does the input describe a computation that Halts) shows the question is
correct.

That no decider can give the right answer to the particular input built
on it, shows that the problem is uncomputable.

You are just admitting the thing you are trying to prove wrong.

You are just proving your ignorance, and that you have POOP on your brain.

On 8/02/24 19:28, olcott wrote:
> On 2/8/2024 12:15 PM, immibis wrote:
>> On 8/02/24 19:09, olcott wrote:
>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>> On 8/02/24 15:14, olcott wrote:
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>
>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>> possibly exist, an infinite set of Turing machines such that each one
>>>>> gets the wrong answer when it is required to report its own halt
>>>>> status.
>>>>
>>>> This proves that it is impossible to for any Ĥ to give the right
>>>> answer on all inputs.
>>>
>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>> question where both yes and no are the wrong answer.
>>
>> No, it proves the right answer is the opposite of what it says.
>>
>
> *This seems to be over your head*
> A self-contradictory question never has any correct answer.
>
The question isn't self-contradictory. It has a right answer.

On 9/02/24 04:34, olcott wrote:
> On 2/8/2024 8:40 PM, Richard Damon wrote:
>> On 2/8/24 7:48 PM, olcott wrote:
>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>
>>>>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>>>>> possibly exist, an infinite set of Turing machines such that
>>>>>>>>> each one
>>>>>>>>> gets the wrong answer when it is required to report its own
>>>>>>>>> halt status.
>>>>>>>>
>>>>>>>> This proves that it is impossible to for any Ĥ to give the right
>>>>>>>> answer on all inputs.
>>>>>>>
>>>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>>>> question where both yes and no are the wrong answer.
>>>>>>
>>>>>> No, it proves the right answer is the opposite of what it says.
>>>>>>
>>>>>
>>>>> *This seems to be over your head*
>>>>> A self-contradictory question never has any correct answer.
>>>>>
>>>>
>>>> So the Halting Question, does the computation described by the input
>>>> Halt? isn't a self-contradictory question, as it always has a
>>>> correct answer, the opposite of what H gives (if it gives one).
>>>>
>>>> Thus, your premise is false.
>>>
>>> Maybe you need to carefully reread this fifty to sixty times before
>>> you get it? (it took me twenty years to get it this simple)
>>>
>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the
>>> wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>
>>
>> But Ĥ doesn't need to report on anything, the copy of H that is in it
>> does.
>>
>>>
>>> Do you understand that every possible element of an infinite set is
>>> more than one element?
>>>
>>
>> Right, so the set isn't a specific input, so not the thing that
>> Halting quesiton is about.
>>
>> The Haltig problem is about making a decider that answers the Halting
>> QUestion which asks the decider about the SPECIFIC COMPUTATION (a
>> specific program/data) that the input describes.
>>
>> Not about "sets" of Decider / Inputs
>>
>
> When an infinite set of decider/input pairs has no correct
> answer then the question is rigged.
>

Is the question "what positive integer should I subtract from 3 to make
5?" rigged? Or does it just have no correct answer?

The question "Does Dan(Dan) halt?" has an answer, and the answer is yes.
The question "Does Dah(Dah) halt?" has an answer, and the answer is no.
The question "What is the code for a halt decider?" has no answer,
because there aren't any halt deciders. It is like asking "what colour
is the elephant in the room?"

On 2/8/2024 9:44 PM, Richard Damon wrote:
> On 2/8/24 10:34 PM, olcott wrote:
>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>> On 2/8/24 7:48 PM, olcott wrote:
>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>>
>>>>>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>>>>>> possibly exist, an infinite set of Turing machines such that
>>>>>>>>>> each one
>>>>>>>>>> gets the wrong answer when it is required to report its own
>>>>>>>>>> halt status.
>>>>>>>>>
>>>>>>>>> This proves that it is impossible to for any Ĥ to give the
>>>>>>>>> right answer on all inputs.
>>>>>>>>
>>>>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>
>>>>>>> No, it proves the right answer is the opposite of what it says.
>>>>>>>
>>>>>>
>>>>>> *This seems to be over your head*
>>>>>> A self-contradictory question never has any correct answer.
>>>>>>
>>>>>
>>>>> So the Halting Question, does the computation described by the
>>>>> input Halt? isn't a self-contradictory question, as it always has a
>>>>> correct answer, the opposite of what H gives (if it gives one).
>>>>>
>>>>> Thus, your premise is false.
>>>>
>>>> Maybe you need to carefully reread this fifty to sixty times before
>>>> you get it? (it took me twenty years to get it this simple)
>>>>
>>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the
>>>> wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>>
>>>
>>> But Ĥ doesn't need to report on anything, the copy of H that is in it
>>> does.
>>>
>>>>
>>>> Do you understand that every possible element of an infinite set is
>>>> more than one element?
>>>>
>>>
>>> Right, so the set isn't a specific input, so not the thing that
>>> Halting quesiton is about.
>>>
>>> The Haltig problem is about making a decider that answers the Halting
>>> QUestion which asks the decider about the SPECIFIC COMPUTATION (a
>>> specific program/data) that the input describes.
>>>
>>> Not about "sets" of Decider / Inputs
>>>
>>
>> When an infinite set of decider/input pairs has no correct
>> answer then the question is rigged.
>>
>
> Except that EVERY element of that set had a correct answer, just not the
> one the decider gave.

When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to contradict
every value that each embedded_H returns for the infinite set of
every Ĥ that can possibly exist then each and every element of
these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory question.

That this is too difficult for you to understand does not entail
that I am incorrect. For me to be actually incorrect you must point
to actual incoherence directly in my view. So far every rebuttal
has been the form "I just don't believe it."

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

On 2/8/2024 9:58 PM, immibis wrote:
> On 9/02/24 04:34, olcott wrote:
>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>> On 2/8/24 7:48 PM, olcott wrote:
>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>>
>>>>>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>>>>>> possibly exist, an infinite set of Turing machines such that
>>>>>>>>>> each one
>>>>>>>>>> gets the wrong answer when it is required to report its own
>>>>>>>>>> halt status.
>>>>>>>>>
>>>>>>>>> This proves that it is impossible to for any Ĥ to give the
>>>>>>>>> right answer on all inputs.
>>>>>>>>
>>>>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>
>>>>>>> No, it proves the right answer is the opposite of what it says.
>>>>>>>
>>>>>>
>>>>>> *This seems to be over your head*
>>>>>> A self-contradictory question never has any correct answer.
>>>>>>
>>>>>
>>>>> So the Halting Question, does the computation described by the
>>>>> input Halt? isn't a self-contradictory question, as it always has a
>>>>> correct answer, the opposite of what H gives (if it gives one).
>>>>>
>>>>> Thus, your premise is false.
>>>>
>>>> Maybe you need to carefully reread this fifty to sixty times before
>>>> you get it? (it took me twenty years to get it this simple)
>>>>
>>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the
>>>> wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>>
>>>
>>> But Ĥ doesn't need to report on anything, the copy of H that is in it
>>> does.
>>>
>>>>
>>>> Do you understand that every possible element of an infinite set is
>>>> more than one element?
>>>>
>>>
>>> Right, so the set isn't a specific input, so not the thing that
>>> Halting quesiton is about.
>>>
>>> The Haltig problem is about making a decider that answers the Halting
>>> QUestion which asks the decider about the SPECIFIC COMPUTATION (a
>>> specific program/data) that the input describes.
>>>
>>> Not about "sets" of Decider / Inputs
>>>
>>
>> When an infinite set of decider/input pairs has no correct
>> answer then the question is rigged.
>>
>
> Is the question "what positive integer should I subtract from 3 to make
> 5?" rigged? Or does it just have no correct answer?
>

It is rigged. What time is it (yes or no)? is also rigged.
When-so-ever the solution set is defined to be the empty set the
question is rigged.

--
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-02-08 15:15:54 +0000, olcott said:

> On 2/8/2024 9:11 AM, Mikko wrote:
>> On 2024-02-08 14:39:05 +0000, olcott said:
>>
>>> On 2/8/2024 8:33 AM, Mikko wrote:
>>>> On 2024-02-08 14:14:55 +0000, olcott said:
>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>
>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>> possibly exist, an infinite set of Turing machines such that each one
>>>>> gets the wrong answer when it is required to report its own halt status.
>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>
>>>>> This proves that the halting problem counter-example
>>>>> <is> isomorphic to the Liar Paradox.
>>>>
>>>> Ĥ is not required to report anything. Linz only specifies how Ĥ is
>>>> constructed but not what it should do.
>>>>
>>>
>>> *Clearly you didn't read what he said on the link*
>>
>> The point is not what he said but what he didn't say. He didn't
>> say what Ĥ is required to do.
>>
>
> He did say what Ĥ is required to do
> and you simply didn't read what he said.

No, he didn't. Otherwise you would show where in that text is the word
"require" or something that means the same. But you don't because he
didn's say.

--
Mikko

On 2/9/24 12:22 AM, olcott wrote:
> On 2/8/2024 9:44 PM, Richard Damon wrote:
>> On 2/8/24 10:34 PM, olcott wrote:
>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>>>
>>>>>>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>>>>>>> possibly exist, an infinite set of Turing machines such that
>>>>>>>>>>> each one
>>>>>>>>>>> gets the wrong answer when it is required to report its own
>>>>>>>>>>> halt status.
>>>>>>>>>>
>>>>>>>>>> This proves that it is impossible to for any Ĥ to give the
>>>>>>>>>> right answer on all inputs.
>>>>>>>>>
>>>>>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>
>>>>>>>> No, it proves the right answer is the opposite of what it says.
>>>>>>>>
>>>>>>>
>>>>>>> *This seems to be over your head*
>>>>>>> A self-contradictory question never has any correct answer.
>>>>>>>
>>>>>>
>>>>>> So the Halting Question, does the computation described by the
>>>>>> input Halt? isn't a self-contradictory question, as it always has
>>>>>> a correct answer, the opposite of what H gives (if it gives one).
>>>>>>
>>>>>> Thus, your premise is false.
>>>>>
>>>>> Maybe you need to carefully reread this fifty to sixty times before
>>>>> you get it? (it took me twenty years to get it this simple)
>>>>>
>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the
>>>>> wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>>>
>>>>
>>>> But Ĥ doesn't need to report on anything, the copy of H that is in
>>>> it does.
>>>>
>>>>>
>>>>> Do you understand that every possible element of an infinite set is
>>>>> more than one element?
>>>>>
>>>>
>>>> Right, so the set isn't a specific input, so not the thing that
>>>> Halting quesiton is about.
>>>>
>>>> The Haltig problem is about making a decider that answers the
>>>> Halting QUestion which asks the decider about the SPECIFIC
>>>> COMPUTATION (a specific program/data) that the input describes.
>>>>
>>>> Not about "sets" of Decider / Inputs
>>>>
>>>
>>> When an infinite set of decider/input pairs has no correct
>>> answer then the question is rigged.
>>>
>>
>> Except that EVERY element of that set had a correct answer, just not
>> the one the decider gave.
>
> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to contradict
> every value that each embedded_H returns for the infinite set of
> every Ĥ that can possibly exist then each and every element of
> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory question.

No, YOUR POOP question, is self-contradictory.

The Halting Question is not, as EVERY element of that set you talk about
has a correct answer to it, as every specific input describes a Halting
Computation or not.

Note, your POOP question is an incorrect question as it ignores that
fact that a given H can't "choose" its answer to try and be correct, but
its answer is FIXED by its definition.

It is like asking what name should Mary have been born with to sound
like a race. Questions about changing what your basic identity has been
are just invalid.

>
> That this is too difficult for you to understand does not entail
> that I am incorrect. For me to be actually incorrect you must point
> to actual incoherence directly in my view. So far every rebuttal
> has been the form "I just don't believe it."
>

Nope, that you think this shows you don't understand anything that you
talk about, but are just a pathological liar.

On 2/9/24 12:26 AM, olcott wrote:
> On 2/8/2024 9:58 PM, immibis wrote:
>> On 9/02/24 04:34, olcott wrote:
>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>>>
>>>>>>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>>>>>>> possibly exist, an infinite set of Turing machines such that
>>>>>>>>>>> each one
>>>>>>>>>>> gets the wrong answer when it is required to report its own
>>>>>>>>>>> halt status.
>>>>>>>>>>
>>>>>>>>>> This proves that it is impossible to for any Ĥ to give the
>>>>>>>>>> right answer on all inputs.
>>>>>>>>>
>>>>>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>
>>>>>>>> No, it proves the right answer is the opposite of what it says.
>>>>>>>>
>>>>>>>
>>>>>>> *This seems to be over your head*
>>>>>>> A self-contradictory question never has any correct answer.
>>>>>>>
>>>>>>
>>>>>> So the Halting Question, does the computation described by the
>>>>>> input Halt? isn't a self-contradictory question, as it always has
>>>>>> a correct answer, the opposite of what H gives (if it gives one).
>>>>>>
>>>>>> Thus, your premise is false.
>>>>>
>>>>> Maybe you need to carefully reread this fifty to sixty times before
>>>>> you get it? (it took me twenty years to get it this simple)
>>>>>
>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the
>>>>> wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>>>
>>>>
>>>> But Ĥ doesn't need to report on anything, the copy of H that is in
>>>> it does.
>>>>
>>>>>
>>>>> Do you understand that every possible element of an infinite set is
>>>>> more than one element?
>>>>>
>>>>
>>>> Right, so the set isn't a specific input, so not the thing that
>>>> Halting quesiton is about.
>>>>
>>>> The Haltig problem is about making a decider that answers the
>>>> Halting QUestion which asks the decider about the SPECIFIC
>>>> COMPUTATION (a specific program/data) that the input describes.
>>>>
>>>> Not about "sets" of Decider / Inputs
>>>>
>>>
>>> When an infinite set of decider/input pairs has no correct
>>> answer then the question is rigged.
>>>
>>
>> Is the question "what positive integer should I subtract from 3 to
>> make 5?" rigged? Or does it just have no correct answer?
>>
>
> It is rigged. What time is it (yes or no)? is also rigged.
> When-so-ever the solution set is defined to be the empty set the
> question is rigged.
>

So, your brain is rigged?

Many LEGITIMATE questions have as an answer the empty set.

On 2/9/2024 1:07 AM, Mikko wrote:
> On 2024-02-08 15:15:54 +0000, olcott said:
>
>> On 2/8/2024 9:11 AM, Mikko wrote:
>>> On 2024-02-08 14:39:05 +0000, olcott said:
>>>
>>>> On 2/8/2024 8:33 AM, Mikko wrote:
>>>>> On 2024-02-08 14:14:55 +0000, olcott said:
>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>
>>>>>> The above pair of templates specify every encoding of Ĥ that can
>>>>>> possibly exist, an infinite set of Turing machines such that each one
>>>>>> gets the wrong answer when it is required to report its own halt
>>>>>> status.
>>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>>
>>>>>> This proves that the halting problem counter-example
>>>>>> <is> isomorphic to the Liar Paradox.
>>>>>
>>>>> Ĥ is not required to report anything. Linz only specifies how Ĥ is
>>>>> constructed but not what it should do.
>>>>>
>>>>
>>>> *Clearly you didn't read what he said on the link*
>>>
>>> The point is not what he said but what he didn't say. He didn't
>>> say what Ĥ is required to do.
>>>
>>
>> He did say what Ĥ is required to do
>> and you simply didn't read what he said.
>
> No, he didn't. Otherwise you would show where in that text is the word
> "require" or something that means the same. But you don't because he
> didn's say.
>

We can therefore legitimately ask what would happen if Ĥ is
applied to ŵ. (middle of page 3)
https://www.liarparadox.org/Linz_Proof.pdf

In my notational conventions it would be: Ĥ applied to ⟨Ĥ⟩.

When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the wrong
answer for every possible Ĥ applied to ⟨Ĥ⟩.

When every possible Ĥ of the infinite set of Ĥ is applied to
its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
to be self-contradictory.

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

On 2/9/2024 6:05 AM, Richard Damon wrote:
> On 2/9/24 12:22 AM, olcott wrote:
>> On 2/8/2024 9:44 PM, Richard Damon wrote:
>>> On 2/8/24 10:34 PM, olcott wrote:
>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>>>>
>>>>>>>>>>>> The above pair of templates specify every encoding of Ĥ that
>>>>>>>>>>>> can
>>>>>>>>>>>> possibly exist, an infinite set of Turing machines such that
>>>>>>>>>>>> each one
>>>>>>>>>>>> gets the wrong answer when it is required to report its own
>>>>>>>>>>>> halt status.
>>>>>>>>>>>
>>>>>>>>>>> This proves that it is impossible to for any Ĥ to give the
>>>>>>>>>>> right answer on all inputs.
>>>>>>>>>>
>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>
>>>>>>>>> No, it proves the right answer is the opposite of what it says.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *This seems to be over your head*
>>>>>>>> A self-contradictory question never has any correct answer.
>>>>>>>>
>>>>>>>
>>>>>>> So the Halting Question, does the computation described by the
>>>>>>> input Halt? isn't a self-contradictory question, as it always has
>>>>>>> a correct answer, the opposite of what H gives (if it gives one).
>>>>>>>
>>>>>>> Thus, your premise is false.
>>>>>>
>>>>>> Maybe you need to carefully reread this fifty to sixty times
>>>>>> before you get it? (it took me twenty years to get it this simple)
>>>>>>
>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the
>>>>>> wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>>>>
>>>>>
>>>>> But Ĥ doesn't need to report on anything, the copy of H that is in
>>>>> it does.
>>>>>
>>>>>>
>>>>>> Do you understand that every possible element of an infinite set
>>>>>> is more than one element?
>>>>>>
>>>>>
>>>>> Right, so the set isn't a specific input, so not the thing that
>>>>> Halting quesiton is about.
>>>>>
>>>>> The Haltig problem is about making a decider that answers the
>>>>> Halting QUestion which asks the decider about the SPECIFIC
>>>>> COMPUTATION (a specific program/data) that the input describes.
>>>>>
>>>>> Not about "sets" of Decider / Inputs
>>>>>
>>>>
>>>> When an infinite set of decider/input pairs has no correct
>>>> answer then the question is rigged.
>>>>
>>>
>>> Except that EVERY element of that set had a correct answer, just not
>>> the one the decider gave.
>>
>> When Ĥ applied to ⟨Ĥ⟩ has been intentionally defined to contradict
>> every value that each embedded_H returns for the infinite set of
>> every Ĥ that can possibly exist then each and every element of
>> these Ĥ / ⟨Ĥ⟩ pairs is isomorphic to a self-contradictory question.
>
> No, YOUR POOP question, is self-contradictory.
>
> The Halting Question is not, as EVERY element of that set you talk about
> has a correct answer to it, as every specific input describes a Halting
> Computation or not.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

When every possible Ĥ of the infinite set of Ĥ is applied to
its own machine description: ⟨Ĥ⟩ then Ĥ is intentionally defined
to be self-contradictory.

The issue is not that the most powerful model of computation is
too weak. The issue is that an input was intentionally defined
to be self-contradictory.

I got involved with these in 2004
(a) The Liar Paradox
(b) Gödel's 1931 incompleteness theorem
(c) The halting problem
and in about 2016 with the Tarski Undefinability theorem
because they prove that human understanding of the notion
of analytical truth is incoherent.

As recently as 1975 one of the greatest minds in the field
did not seem to understand that the Liar Paradox is simply
not a truth bearer.
https://www.impan.pl/~kz/truthseminar/Kripke_Outline.pdf

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

On 2/9/2024 6:05 AM, Richard Damon wrote:
> On 2/9/24 12:26 AM, olcott wrote:
>> On 2/8/2024 9:58 PM, immibis wrote:
>>> On 9/02/24 04:34, olcott wrote:
>>>> On 2/8/2024 8:40 PM, Richard Damon wrote:
>>>>> On 2/8/24 7:48 PM, olcott wrote:
>>>>>> On 2/8/2024 5:50 PM, Richard Damon wrote:
>>>>>>> On 2/8/24 1:28 PM, olcott wrote:
>>>>>>>> On 2/8/2024 12:15 PM, immibis wrote:
>>>>>>>>> On 8/02/24 19:09, olcott wrote:
>>>>>>>>>> On 2/8/2024 10:32 AM, immibis wrote:
>>>>>>>>>>> On 8/02/24 15:14, olcott wrote:
>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // wrong answer
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn   // wrong answer
>>>>>>>>>>>>
>>>>>>>>>>>> The above pair of templates specify every encoding of Ĥ that
>>>>>>>>>>>> can
>>>>>>>>>>>> possibly exist, an infinite set of Turing machines such that
>>>>>>>>>>>> each one
>>>>>>>>>>>> gets the wrong answer when it is required to report its own
>>>>>>>>>>>> halt status.
>>>>>>>>>>>
>>>>>>>>>>> This proves that it is impossible to for any Ĥ to give the
>>>>>>>>>>> right answer on all inputs.
>>>>>>>>>>
>>>>>>>>>> It proves that asking Ĥ whether it halts or not is an incorrect
>>>>>>>>>> question where both yes and no are the wrong answer.
>>>>>>>>>
>>>>>>>>> No, it proves the right answer is the opposite of what it says.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *This seems to be over your head*
>>>>>>>> A self-contradictory question never has any correct answer.
>>>>>>>>
>>>>>>>
>>>>>>> So the Halting Question, does the computation described by the
>>>>>>> input Halt? isn't a self-contradictory question, as it always has
>>>>>>> a correct answer, the opposite of what H gives (if it gives one).
>>>>>>>
>>>>>>> Thus, your premise is false.
>>>>>>
>>>>>> Maybe you need to carefully reread this fifty to sixty times
>>>>>> before you get it? (it took me twenty years to get it this simple)
>>>>>>
>>>>>> When Ĥ is to report on its own behavior both Ĥ.qy and Ĥ.qn are the
>>>>>> wrong answer for every possible Ĥ applied to ⟨Ĥ⟩.
>>>>>
>>>>>
>>>>> But Ĥ doesn't need to report on anything, the copy of H that is in
>>>>> it does.
>>>>>
>>>>>>
>>>>>> Do you understand that every possible element of an infinite set
>>>>>> is more than one element?
>>>>>>
>>>>>
>>>>> Right, so the set isn't a specific input, so not the thing that
>>>>> Halting quesiton is about.
>>>>>
>>>>> The Haltig problem is about making a decider that answers the
>>>>> Halting QUestion which asks the decider about the SPECIFIC
>>>>> COMPUTATION (a specific program/data) that the input describes.
>>>>>
>>>>> Not about "sets" of Decider / Inputs
>>>>>
>>>>
>>>> When an infinite set of decider/input pairs has no correct
>>>> answer then the question is rigged.
>>>>
>>>
>>> Is the question "what positive integer should I subtract from 3 to
>>> make 5?" rigged? Or does it just have no correct answer?
>>>
>>
>> It is rigged. What time is it (yes or no)? is also rigged.
>> When-so-ever the solution set is defined to be the empty set the
>> question is rigged.
>>
>
> So, your brain is rigged?
>
> Many LEGITIMATE questions have as an answer the empty set.

No polar (YES/NO) question can correctly have the empty set as an
answer. The whole idea of vacuous truth is a ruse.

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