Within the assumption that the input to a hypothetical halt decider
represents the underlying computation then when hypothetical halt
decider H is applied to its own Turing machine description ⟨H⟩ it is
reporting on its own behavior. This means that when hypothetical Turing
machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
itself returns this makes Ĥ self-contradictory.

// Linz Turing machine H template adapted to copy its input
// --- Does Ȟ halt on ⟨Ȟ⟩ its own machine description?
Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt

Of the infinite set of implementations of Ȟ every one that transitions
to H.qy derives an answer consistent with the behavior of Ȟ.

*Above machine adapted to become self-contradictory*

// Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
// its own Turing Machine description
// --- Does Ĥ halt on ⟨Ĥ⟩ its own machine description?
Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt

Of the infinite set of implementations of Ĥ none of them derives an
answer consistent with the behavior of Ĥ.

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

On 26/02/24 21:02, olcott wrote:
> Within the assumption that the input to a hypothetical halt decider
> represents the underlying computation then when hypothetical halt
> decider H is applied to its own Turing machine description ⟨H⟩ it is
> reporting on its own behavior. This means that when hypothetical Turing
> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
> itself returns this makes Ĥ self-contradictory.

What is the definition of a self-contradictory Turing machine?

>
> // Linz Turing machine H template adapted to copy its input
> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt

A single Turing machine cannot fork.

>
> Of the infinite set of implementations of Ȟ every one that transitions
> to H.qy derives an answer consistent with the behavior of Ȟ.
>
> *Above machine adapted to become self-contradictory*
>
> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
> // its own Turing Machine description
> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Of the infinite set of implementations of Ĥ none of them derives an
> answer consistent with the behavior of Ĥ.

By equating two different implementations you created nonsense. You
tried to talk about one Turing machine that is actually several
different Turing machines. Do you think that copy-pasting the same
nonsense makes it stop being nonsense?

On 2/26/2024 2:11 PM, immibis wrote:
> On 26/02/24 21:02, olcott wrote:
>> Within the assumption that the input to a hypothetical halt decider
>> represents the underlying computation then when hypothetical halt
>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>> reporting on its own behavior. This means that when hypothetical Turing
>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
>> itself returns this makes Ĥ self-contradictory.
>
> What is the definition of a self-contradictory Turing machine?
>
>>
>> // Linz Turing machine H template adapted to copy its input
>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>
> A single Turing machine cannot fork.
>
>>
>> Of the infinite set of implementations of Ȟ every one that transitions
>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>
>> *Above machine adapted to become self-contradictory*
>>
>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>> // its own Turing Machine description
>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Of the infinite set of implementations of Ĥ none of them derives an
>> answer consistent with the behavior of Ĥ.
>
> By equating two different implementations you created nonsense. You
> tried to talk about one Turing machine that is actually several
> different Turing machines. Do you think that copy-pasting the same
> nonsense makes it stop being nonsense?

When I refer to every element of an infinite set then people
that are not jackasses would acknowledge that there are zero
elements of the set of every possible implementation of
Ĥ applied to ⟨Ĥ⟩ that I did not refer to.

--
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/26/2024 2:02 PM, olcott wrote:
> Within the assumption that the input to a hypothetical halt decider
> represents the underlying computation then when hypothetical halt
> decider H is applied to its own Turing machine description ⟨H⟩ it is
> reporting on its own behavior. This means that when hypothetical Turing
> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
> itself returns this makes Ĥ self-contradictory.
>
> // Linz Turing machine H template adapted to copy its input
> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>
> Of the infinite set of implementations of Ȟ every one that transitions
> to H.qy derives an answer consistent with the behavior of Ȟ.
>
> *Above machine adapted to become self-contradictory*
>
> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
> // its own Turing Machine description
> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Of the infinite set of implementations of Ĥ none of them derives an
> answer consistent with the behavior of Ĥ.
>

When the only difference between two machine templates is that
one is self-contradictory and the other is not and every
implementation of the self-contradictory template is undecidable
and the other is not then it doesn't take a genius to understand
that it is the self-contradiction that causes undecidability.

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

On 26/02/24 21:38, olcott wrote:
> On 2/26/2024 2:02 PM, olcott wrote:
>> Within the assumption that the input to a hypothetical halt decider
>> represents the underlying computation then when hypothetical halt
>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>> reporting on its own behavior. This means that when hypothetical Turing
>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
>> itself returns this makes Ĥ self-contradictory.
>>
>> // Linz Turing machine H template adapted to copy its input
>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>
>> Of the infinite set of implementations of Ȟ every one that transitions
>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>
>> *Above machine adapted to become self-contradictory*
>>
>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>> // its own Turing Machine description
>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Of the infinite set of implementations of Ĥ none of them derives an
>> answer consistent with the behavior of Ĥ.
>>
>
> When the only difference between two machine templates is that
> one is self-contradictory and the other is not and every
> implementation of the self-contradictory template is undecidable

Saying that a Turing machine is undecidable is a category error, like
saying the number 5 is loud.

On 2/26/2024 2:51 PM, immibis wrote:
> On 26/02/24 21:38, olcott wrote:
>> On 2/26/2024 2:02 PM, olcott wrote:
>>> Within the assumption that the input to a hypothetical halt decider
>>> represents the underlying computation then when hypothetical halt
>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>> reporting on its own behavior. This means that when hypothetical Turing
>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
>>> itself returns this makes Ĥ self-contradictory.
>>>
>>> // Linz Turing machine H template adapted to copy its input
>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>
>>> Of the infinite set of implementations of Ȟ every one that transitions
>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>
>>> *Above machine adapted to become self-contradictory*
>>>
>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>> // its own Turing Machine description
>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Of the infinite set of implementations of Ĥ none of them derives an
>>> answer consistent with the behavior of Ĥ.
>>>
>>
>> When the only difference between two machine templates is that
>> one is self-contradictory and the other is not and every
>> implementation of the self-contradictory template is undecidable
>
> Saying that a Turing machine is undecidable is a category error, like
> saying the number 5 is loud.
>
Every instance of Ĥ applied to ⟨Ĥ⟩ derives a machine
that does not correctly report its own behavior.

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

On 26/02/24 22:14, olcott wrote:
> On 2/26/2024 2:51 PM, immibis wrote:
>> On 26/02/24 21:38, olcott wrote:
>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>> Within the assumption that the input to a hypothetical halt decider
>>>> represents the underlying computation then when hypothetical halt
>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>> reporting on its own behavior. This means that when hypothetical Turing
>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value
>>>> that
>>>> itself returns this makes Ĥ self-contradictory.
>>>>
>>>> // Linz Turing machine H template adapted to copy its input
>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>
>>>> Of the infinite set of implementations of Ȟ every one that transitions
>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>
>>>> *Above machine adapted to become self-contradictory*
>>>>
>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>> // its own Turing Machine description
>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>> answer consistent with the behavior of Ĥ.
>>>>
>>>
>>> When the only difference between two machine templates is that
>>> one is self-contradictory and the other is not and every
>>> implementation of the self-contradictory template is undecidable
>>
>> Saying that a Turing machine is undecidable is a category error, like
>> saying the number 5 is loud.
>>
> Every instance of Ĥ applied to ⟨Ĥ⟩ derives a machine
> that does not correctly report its own behavior.
>

No Ĥ reports on anything's behavior.

On 2/26/2024 3:42 PM, immibis wrote:
> On 26/02/24 22:14, olcott wrote:
>> On 2/26/2024 2:51 PM, immibis wrote:
>>> On 26/02/24 21:38, olcott wrote:
>>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>>> Within the assumption that the input to a hypothetical halt decider
>>>>> represents the underlying computation then when hypothetical halt
>>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>>> reporting on its own behavior. This means that when hypothetical
>>>>> Turing
>>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value
>>>>> that
>>>>> itself returns this makes Ĥ self-contradictory.
>>>>>
>>>>> // Linz Turing machine H template adapted to copy its input
>>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>
>>>>> Of the infinite set of implementations of Ȟ every one that transitions
>>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>>
>>>>> *Above machine adapted to become self-contradictory*
>>>>>
>>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>>> // its own Turing Machine description
>>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>>> answer consistent with the behavior of Ĥ.
>>>>>
>>>>
>>>> When the only difference between two machine templates is that
>>>> one is self-contradictory and the other is not and every
>>>> implementation of the self-contradictory template is undecidable
>>>
>>> Saying that a Turing machine is undecidable is a category error, like
>>> saying the number 5 is loud.
>>>
>> Every instance of Ĥ applied to ⟨Ĥ⟩ derives a machine
>> that does not correctly report its own behavior.
>>
>
> No Ĥ reports on anything's behavior.

When Ĥ is a termination analyzer applied to its
own Turing Machine description and Ĥ always halts
then every Ĥ correctly reports the opposite of
its own behavior.

--
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/26/2024 4:09 PM, olcott wrote:
> On 2/26/2024 3:42 PM, immibis wrote:
>> On 26/02/24 22:14, olcott wrote:
>>> On 2/26/2024 2:51 PM, immibis wrote:
>>>> On 26/02/24 21:38, olcott wrote:
>>>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>>>> Within the assumption that the input to a hypothetical halt
>>>>>> decider represents the underlying computation then when
>>>>>> hypothetical halt
>>>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>>>> reporting on its own behavior. This means that when hypothetical
>>>>>> Turing
>>>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every
>>>>>> value that
>>>>>> itself returns this makes Ĥ self-contradictory.
>>>>>>
>>>>>> // Linz Turing machine H template adapted to copy its input
>>>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>
>>>>>> Of the infinite set of implementations of Ȟ every one that
>>>>>> transitions
>>>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>>>
>>>>>> *Above machine adapted to become self-contradictory*
>>>>>>
>>>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>>>> // its own Turing Machine description
>>>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>>>> answer consistent with the behavior of Ĥ.
>>>>>>
>>>>>
>>>>> When the only difference between two machine templates is that
>>>>> one is self-contradictory and the other is not and every
>>>>> implementation of the self-contradictory template is undecidable
>>>>
>>>> Saying that a Turing machine is undecidable is a category error,
>>>> like saying the number 5 is loud.
>>>>
>>> Every instance of Ĥ applied to ⟨Ĥ⟩ derives a machine
>>> that does not correctly report its own behavior.
>>>
>>
>> No Ĥ reports on anything's behavior.
>
> When Ĥ is a termination analyzer applied to its
> own Turing Machine description and Ĥ always halts
> then every Ĥ correctly reports the opposite of
> its own behavior.
>

When Ĥ is a termination analyzer applied to its
own Turing Machine description then every Ĥ never
correctly reports on its own behavior.

--
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/26/24 5:09 PM, olcott wrote:
> On 2/26/2024 3:42 PM, immibis wrote:
>> On 26/02/24 22:14, olcott wrote:
>>> On 2/26/2024 2:51 PM, immibis wrote:
>>>> On 26/02/24 21:38, olcott wrote:
>>>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>>>> Within the assumption that the input to a hypothetical halt
>>>>>> decider represents the underlying computation then when
>>>>>> hypothetical halt
>>>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>>>> reporting on its own behavior. This means that when hypothetical
>>>>>> Turing
>>>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every
>>>>>> value that
>>>>>> itself returns this makes Ĥ self-contradictory.
>>>>>>
>>>>>> // Linz Turing machine H template adapted to copy its input
>>>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>
>>>>>> Of the infinite set of implementations of Ȟ every one that
>>>>>> transitions
>>>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>>>
>>>>>> *Above machine adapted to become self-contradictory*
>>>>>>
>>>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>>>> // its own Turing Machine description
>>>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>>>> answer consistent with the behavior of Ĥ.
>>>>>>
>>>>>
>>>>> When the only difference between two machine templates is that
>>>>> one is self-contradictory and the other is not and every
>>>>> implementation of the self-contradictory template is undecidable
>>>>
>>>> Saying that a Turing machine is undecidable is a category error,
>>>> like saying the number 5 is loud.
>>>>
>>> Every instance of Ĥ applied to ⟨Ĥ⟩ derives a machine
>>> that does not correctly report its own behavior.
>>>
>>
>> No Ĥ reports on anything's behavior.
>
> When Ĥ is a termination analyzer applied to its
> own Turing Machine description and Ĥ always halts
> then every Ĥ correctly reports the opposite of
> its own behavior.
>

But it ISN'T, since it doesn't halt to give the answer.

THe adding of the infinte loop to the Qy state means that Ĥ no longer
"Reports" an answer.

IF you were given a question, and told you could only answer "No", would
that be a fair questioning?

Ĥ is broken because it can only answer no, when answering no means it
needed to answer yes, which it isn't ALLOWED to do.

You are just proving your fundamental misunderstanding of the basics of
the field.

On 2/26/24 4:14 PM, olcott wrote:
> On 2/26/2024 2:51 PM, immibis wrote:
>> On 26/02/24 21:38, olcott wrote:
>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>> Within the assumption that the input to a hypothetical halt decider
>>>> represents the underlying computation then when hypothetical halt
>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>> reporting on its own behavior. This means that when hypothetical Turing
>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value
>>>> that
>>>> itself returns this makes Ĥ self-contradictory.
>>>>
>>>> // Linz Turing machine H template adapted to copy its input
>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>
>>>> Of the infinite set of implementations of Ȟ every one that transitions
>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>
>>>> *Above machine adapted to become self-contradictory*
>>>>
>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>> // its own Turing Machine description
>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>> answer consistent with the behavior of Ĥ.
>>>>
>>>
>>> When the only difference between two machine templates is that
>>> one is self-contradictory and the other is not and every
>>> implementation of the self-contradictory template is undecidable
>>
>> Saying that a Turing machine is undecidable is a category error, like
>> saying the number 5 is loud.
>>
> Every instance of Ĥ applied to ⟨Ĥ⟩ derives a machine
> that does not correctly report its own behavior.
>

SO.

Every input had a correct answer to the halting question.

You are just proving that correct halt deciders don't exist.

On 2/26/24 3:38 PM, olcott wrote:
> On 2/26/2024 2:02 PM, olcott wrote:
>> Within the assumption that the input to a hypothetical halt decider
>> represents the underlying computation then when hypothetical halt
>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>> reporting on its own behavior. This means that when hypothetical Turing
>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
>> itself returns this makes Ĥ self-contradictory.
>>
>> // Linz Turing machine H template adapted to copy its input
>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>
>> Of the infinite set of implementations of Ȟ every one that transitions
>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>
>> *Above machine adapted to become self-contradictory*
>>
>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>> // its own Turing Machine description
>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Of the infinite set of implementations of Ĥ none of them derives an
>> answer consistent with the behavior of Ĥ.
>>
>
> When the only difference between two machine templates is that
> one is self-contradictory and the other is not and every
> implementation of the self-contradictory template is undecidable
> and the other is not then it doesn't take a genius to understand
> that it is the self-contradiction that causes undecidability.
>

No, it shows you have a category error, as Halting isn't about "Templates".

But yes, the fact that Turing Machines (and there equivalent) ALLOW the
creation of a input to be based on a machine that act contrary to the
DECIDER (not "itself") means that every decider has an input that it
gets wrong.

Doesn't make the question about that property "wrong", since other
deciders can give the right answer for that particular machine input
(not the template, the machine), so the question is correct.

Only someone who thinks they can know everything (and clearly doesn't)
would make that sort of mistake.

On 2/26/24 3:18 PM, olcott wrote:
> On 2/26/2024 2:11 PM, immibis wrote:
>> On 26/02/24 21:02, olcott wrote:
>>> Within the assumption that the input to a hypothetical halt decider
>>> represents the underlying computation then when hypothetical halt
>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>> reporting on its own behavior. This means that when hypothetical Turing
>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
>>> itself returns this makes Ĥ self-contradictory.
>>
>> What is the definition of a self-contradictory Turing machine?
>>
>>>
>>> // Linz Turing machine H template adapted to copy its input
>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>
>> A single Turing machine cannot fork.
>>
>>>
>>> Of the infinite set of implementations of Ȟ every one that transitions
>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>
>>> *Above machine adapted to become self-contradictory*
>>>
>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>> // its own Turing Machine description
>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Of the infinite set of implementations of Ĥ none of them derives an
>>> answer consistent with the behavior of Ĥ.
>>
>> By equating two different implementations you created nonsense. You
>> tried to talk about one Turing machine that is actually several
>> different Turing machines. Do you think that copy-pasting the same
>> nonsense makes it stop being nonsense?
>
> When I refer to every element of an infinite set then people
> that are not jackasses would acknowledge that there are zero
> elements of the set of every possible implementation of
> Ĥ applied to ⟨Ĥ⟩ that I did not refer to.
>

Which, as been pointed out, just shows that the question in non-computable.

For EVERY element of that infinite set, there WAS a correct answer to
the Halting Question, Does the machine represented by the input halt on
its input.

This is proven by the fact that every machine is WRONG, and there are
only two possible results for Halting, so the other one must be right.

There are ZERO element that meet the requirements, which you are
admitting as that is your basis for the complaint.

So we have an infinite set of claimants, all who fail, but for ever
claimant, the input it was given actually HAS a correct answer, just not
the one the claimant gave.

On 2/26/24 3:02 PM, olcott wrote:
> Within the assumption that the input to a hypothetical halt decider
> represents the underlying computation then when hypothetical halt
> decider H is applied to its own Turing machine description ⟨H⟩ it is
> reporting on its own behavior. This means that when hypothetical Turing
> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
> itself returns this makes Ĥ self-contradictory.

Which, by the rules of logic, imply that the Hypothetical halt decider
doesn't exist, not that the Halting Question is incorrect.

>
> // Linz Turing machine H template adapted to copy its input
> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>
> Of the infinite set of implementations of Ȟ every one that transitions
> to H.qy derives an answer consistent with the behavior of Ȟ.
>
> *Above machine adapted to become self-contradictory*
>
> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
> // its own Turing Machine description
> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Of the infinite set of implementations of Ĥ none of them derives an
> answer consistent with the behavior of Ĥ.
>

Which just proves that the question in non-computable, not wrong.

Since for EVERY realized input, there is an answer, the quesiton is
correct. (Make an H without the requirement to be correct, and there is
an answer).

On 2/26/2024 7:03 PM, Richard Damon wrote:
> On 2/26/24 3:38 PM, olcott wrote:
>> On 2/26/2024 2:02 PM, olcott wrote:
>>> Within the assumption that the input to a hypothetical halt decider
>>> represents the underlying computation then when hypothetical halt
>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>> reporting on its own behavior. This means that when hypothetical Turing
>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value that
>>> itself returns this makes Ĥ self-contradictory.
>>>
>>> // Linz Turing machine H template adapted to copy its input
>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>
>>> Of the infinite set of implementations of Ȟ every one that transitions
>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>
>>> *Above machine adapted to become self-contradictory*
>>>
>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>> // its own Turing Machine description
>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Of the infinite set of implementations of Ĥ none of them derives an
>>> answer consistent with the behavior of Ĥ.
>>>
>>
>> When the only difference between two machine templates is that
>> one is self-contradictory and the other is not and every
>> implementation of the self-contradictory template is undecidable
>> and the other is not then it doesn't take a genius to understand
>> that it is the self-contradiction that causes undecidability.
>>
>
> No, it shows you have a category error, as Halting isn't about "Templates".
>
> But yes, the fact that Turing Machines (and there equivalent) ALLOW the
> creation of a input to be based on a machine that act contrary to the
> DECIDER (not "itself") means that every decider has an input that it
> gets wrong.

That is isomorphic to saying that a correct True(L, x) predicate
does not exist because it does not correctly determine that a lie
is true.

On 2/23/2024 9:22 PM, Richard Damon wrote:
> Yes, Epistemological antinomies, when given to a True Predicate, get
> "rejected" in a sense, the predicate returns FALSE.
>
> That doesn't mean the statement is false, just that it isn't true.
>
> It also doesn't mean the predicate doesn't answer.

Thus a halt decider returns TRUE for inputs that it correctly
determines will halt and FALSE for everything else including
epistemological antinomies such as Ĥ applied to ⟨Ĥ⟩.

A mere recognizer would simply loop in these cases.

> Doesn't make the question about that property "wrong", since other
> deciders can give the right answer for that particular machine input
> (not the template, the machine), so the question is correct.
>
> Only someone who thinks they can know everything (and clearly doesn't)
> would make that sort of mistake.
>

--
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/26/24 8:21 PM, olcott wrote:
> On 2/26/2024 7:03 PM, Richard Damon wrote:
>> On 2/26/24 3:38 PM, olcott wrote:
>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>> Within the assumption that the input to a hypothetical halt decider
>>>> represents the underlying computation then when hypothetical halt
>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>> reporting on its own behavior. This means that when hypothetical Turing
>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value
>>>> that
>>>> itself returns this makes Ĥ self-contradictory.
>>>>
>>>> // Linz Turing machine H template adapted to copy its input
>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>
>>>> Of the infinite set of implementations of Ȟ every one that transitions
>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>
>>>> *Above machine adapted to become self-contradictory*
>>>>
>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>> // its own Turing Machine description
>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>> answer consistent with the behavior of Ĥ.
>>>>
>>>
>>> When the only difference between two machine templates is that
>>> one is self-contradictory and the other is not and every
>>> implementation of the self-contradictory template is undecidable
>>> and the other is not then it doesn't take a genius to understand
>>> that it is the self-contradiction that causes undecidability.
>>>
>>
>> No, it shows you have a category error, as Halting isn't about
>> "Templates".
>>
>> But yes, the fact that Turing Machines (and there equivalent) ALLOW
>> the creation of a input to be based on a machine that act contrary to
>> the DECIDER (not "itself") means that every decider has an input that
>> it gets wrong.
>
> That is isomorphic to saying that a correct True(L, x) predicate
> does not exist because it does not correctly determine that a lie
> is true.

Nope.

Perhaps you could say that a correct Truth predicate backs itself into a
corner if it has to judge its own work.

Needing to be "Perfect" in results say it needs to become an
irresistible force, but being allowed to bind it to a statement and
giving that to it again, can make the force fight itself.

To avoid that you need to remove the power to bind expressions.

>
> On 2/23/2024 9:22 PM, Richard Damon wrote:
> > Yes, Epistemological antinomies, when given to a True Predicate, get
> > "rejected" in a sense, the predicate returns FALSE.
> >
> > That doesn't mean the statement is false, just that it isn't true.
> >
> > It also doesn't mean the predicate doesn't answer.
>
> Thus a halt decider returns TRUE for inputs that it correctly
> determines will halt and FALSE for everything else including
> epistemological antinomies such as Ĥ applied to ⟨Ĥ⟩.

Nope, it needs to return True for ALL inputs that DO Halt, not just the
ones it correctly determines will halt.

If some DO halt that it doesn't determine to do so, it is just WRONG.

Turing machines can NOT be an "Epistemological Antinomy" that claim is
just a category error.

Perhaps TEMPLATES can be, but not actual machines.

The only way the input could be something like that is if H itself was,
and thus not a correct computation.

>
> A mere recognizer would simply loop in these cases.

Halting Recognizers are trivial.

>
>> Doesn't make the question about that property "wrong", since other
>> deciders can give the right answer for that particular machine input
>> (not the template, the machine), so the question is correct.
>>
>> Only someone who thinks they can know everything (and clearly doesn't)
>> would make that sort of mistake.
>>
>

On 2/26/2024 8:07 PM, Richard Damon wrote:
> On 2/26/24 8:21 PM, olcott wrote:
>> On 2/26/2024 7:03 PM, Richard Damon wrote:
>>> On 2/26/24 3:38 PM, olcott wrote:
>>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>>> Within the assumption that the input to a hypothetical halt decider
>>>>> represents the underlying computation then when hypothetical halt
>>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>>> reporting on its own behavior. This means that when hypothetical
>>>>> Turing
>>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every value
>>>>> that
>>>>> itself returns this makes Ĥ self-contradictory.
>>>>>
>>>>> // Linz Turing machine H template adapted to copy its input
>>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>
>>>>> Of the infinite set of implementations of Ȟ every one that transitions
>>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>>
>>>>> *Above machine adapted to become self-contradictory*
>>>>>
>>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>>> // its own Turing Machine description
>>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>>> answer consistent with the behavior of Ĥ.
>>>>>
>>>>
>>>> When the only difference between two machine templates is that
>>>> one is self-contradictory and the other is not and every
>>>> implementation of the self-contradictory template is undecidable
>>>> and the other is not then it doesn't take a genius to understand
>>>> that it is the self-contradiction that causes undecidability.
>>>>
>>>
>>> No, it shows you have a category error, as Halting isn't about
>>> "Templates".
>>>
>>> But yes, the fact that Turing Machines (and there equivalent) ALLOW
>>> the creation of a input to be based on a machine that act contrary to
>>> the DECIDER (not "itself") means that every decider has an input that
>>> it gets wrong.
>>
>> That is isomorphic to saying that a correct True(L, x) predicate
>> does not exist because it does not correctly determine that a lie
>> is true.
>
> Nope.
>
> Perhaps you could say that a correct Truth predicate backs itself into a
> corner if it has to judge its own work.
>
> Needing to be "Perfect" in results say it needs to become an
> irresistible force, but being allowed to bind it to a statement and
> giving that to it again, can make the force fight itself.
>
> To avoid that you need to remove the power to bind expressions.
>
>>
>> On 2/23/2024 9:22 PM, Richard Damon wrote:
>>  > Yes, Epistemological antinomies, when given to a True Predicate, get
>>  > "rejected" in a sense, the predicate returns FALSE.
>>  >
>>  > That doesn't mean the statement is false, just that it isn't true.
>>  >
>>  > It also doesn't mean the predicate doesn't answer.
>>
>> Thus a halt decider returns TRUE for inputs that it correctly
>> determines will halt and FALSE for everything else including
>> epistemological antinomies such as Ĥ applied to ⟨Ĥ⟩.
>
> Nope, it needs to return True for ALL inputs that DO Halt, not just the
> ones it correctly determines will halt.
>
> If some DO halt that it doesn't determine to do so, it is just WRONG.
>
> Turing machines can NOT be an "Epistemological Antinomy" that claim is
> just a category error.
>
> Perhaps TEMPLATES can be, but not actual machines.

Why do you continue to pretend to be too stupid to
understand that a template specifies and infinite
set of actual machines that all get 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 2/26/24 9:12 PM, olcott wrote:
> On 2/26/2024 8:07 PM, Richard Damon wrote:
>> On 2/26/24 8:21 PM, olcott wrote:
>>> On 2/26/2024 7:03 PM, Richard Damon wrote:
>>>> On 2/26/24 3:38 PM, olcott wrote:
>>>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>>>> Within the assumption that the input to a hypothetical halt
>>>>>> decider represents the underlying computation then when
>>>>>> hypothetical halt
>>>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>>>> reporting on its own behavior. This means that when hypothetical
>>>>>> Turing
>>>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every
>>>>>> value that
>>>>>> itself returns this makes Ĥ self-contradictory.
>>>>>>
>>>>>> // Linz Turing machine H template adapted to copy its input
>>>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>
>>>>>> Of the infinite set of implementations of Ȟ every one that
>>>>>> transitions
>>>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>>>
>>>>>> *Above machine adapted to become self-contradictory*
>>>>>>
>>>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>>>> // its own Turing Machine description
>>>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>>>> answer consistent with the behavior of Ĥ.
>>>>>>
>>>>>
>>>>> When the only difference between two machine templates is that
>>>>> one is self-contradictory and the other is not and every
>>>>> implementation of the self-contradictory template is undecidable
>>>>> and the other is not then it doesn't take a genius to understand
>>>>> that it is the self-contradiction that causes undecidability.
>>>>>
>>>>
>>>> No, it shows you have a category error, as Halting isn't about
>>>> "Templates".
>>>>
>>>> But yes, the fact that Turing Machines (and there equivalent) ALLOW
>>>> the creation of a input to be based on a machine that act contrary
>>>> to the DECIDER (not "itself") means that every decider has an input
>>>> that it gets wrong.
>>>
>>> That is isomorphic to saying that a correct True(L, x) predicate
>>> does not exist because it does not correctly determine that a lie
>>> is true.
>>
>> Nope.
>>
>> Perhaps you could say that a correct Truth predicate backs itself into
>> a corner if it has to judge its own work.
>>
>> Needing to be "Perfect" in results say it needs to become an
>> irresistible force, but being allowed to bind it to a statement and
>> giving that to it again, can make the force fight itself.
>>
>> To avoid that you need to remove the power to bind expressions.
>>
>>>
>>> On 2/23/2024 9:22 PM, Richard Damon wrote:
>>>  > Yes, Epistemological antinomies, when given to a True Predicate, get
>>>  > "rejected" in a sense, the predicate returns FALSE.
>>>  >
>>>  > That doesn't mean the statement is false, just that it isn't true.
>>>  >
>>>  > It also doesn't mean the predicate doesn't answer.
>>>
>>> Thus a halt decider returns TRUE for inputs that it correctly
>>> determines will halt and FALSE for everything else including
>>> epistemological antinomies such as Ĥ applied to ⟨Ĥ⟩.
>>
>> Nope, it needs to return True for ALL inputs that DO Halt, not just
>> the ones it correctly determines will halt.
>>
>> If some DO halt that it doesn't determine to do so, it is just WRONG.
>>
>> Turing machines can NOT be an "Epistemological Antinomy" that claim is
>> just a category error.
>>
>> Perhaps TEMPLATES can be, but not actual machines.
>
> Why do you continue to pretend to be too stupid to
> understand that a template specifies and infinite
> set of actual machines that all get the wrong answer?
>

And why are you so stupid not not see that the ACTUAL QUESTION, ("Does
the Computation described by your input Halt?") isn't about the set or
the template, but about the individual machines, and for each individual
machine, there IS a correct answer, just not the one the decider in the
pair gave, thus there isn't an issue with the actual question, and you
have just proved that Halting Can't be Computed by a machine, which is
the opposite of your claim.

You are just proving your utter stupidity.

On 26/02/24 23:09, olcott wrote:
> On 2/26/2024 3:42 PM, immibis wrote:
>> On 26/02/24 22:14, olcott wrote:
>>> On 2/26/2024 2:51 PM, immibis wrote:
>>>> On 26/02/24 21:38, olcott wrote:
>>>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>>>> Within the assumption that the input to a hypothetical halt
>>>>>> decider represents the underlying computation then when
>>>>>> hypothetical halt
>>>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>>>> reporting on its own behavior. This means that when hypothetical
>>>>>> Turing
>>>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every
>>>>>> value that
>>>>>> itself returns this makes Ĥ self-contradictory.
>>>>>>
>>>>>> // Linz Turing machine H template adapted to copy its input
>>>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>
>>>>>> Of the infinite set of implementations of Ȟ every one that
>>>>>> transitions
>>>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>>>
>>>>>> *Above machine adapted to become self-contradictory*
>>>>>>
>>>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>>>> // its own Turing Machine description
>>>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>>>> answer consistent with the behavior of Ĥ.
>>>>>>
>>>>>
>>>>> When the only difference between two machine templates is that
>>>>> one is self-contradictory and the other is not and every
>>>>> implementation of the self-contradictory template is undecidable
>>>>
>>>> Saying that a Turing machine is undecidable is a category error,
>>>> like saying the number 5 is loud.
>>>>
>>> Every instance of Ĥ applied to ⟨Ĥ⟩ derives a machine
>>> that does not correctly report its own behavior.
>>>
>>
>> No Ĥ reports on anything's behavior.
>
> When Ĥ is a termination analyzer applied to its
> own Turing Machine description and Ĥ always halts
> then every Ĥ correctly reports the opposite of
> its own behavior.
>
Wrong. It could just return 1.

On 26/02/24 23:23, olcott wrote:
> On 2/26/2024 4:09 PM, olcott wrote:
>> On 2/26/2024 3:42 PM, immibis wrote:
>>> On 26/02/24 22:14, olcott wrote:
>>>> On 2/26/2024 2:51 PM, immibis wrote:
>>>>> On 26/02/24 21:38, olcott wrote:
>>>>>> On 2/26/2024 2:02 PM, olcott wrote:
>>>>>>> Within the assumption that the input to a hypothetical halt
>>>>>>> decider represents the underlying computation then when
>>>>>>> hypothetical halt
>>>>>>> decider H is applied to its own Turing machine description ⟨H⟩ it is
>>>>>>> reporting on its own behavior. This means that when hypothetical
>>>>>>> Turing
>>>>>>> machine Ĥ applied to ⟨Ĥ⟩ has been defined to contradict every
>>>>>>> value that
>>>>>>> itself returns this makes Ĥ self-contradictory.
>>>>>>>
>>>>>>> // Linz Turing machine H template adapted to copy its input
>>>>>>> // --- Does  Ȟ halt on ⟨Ȟ⟩ its own machine description?
>>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qy // Ȟ applied to ⟨Ȟ⟩ halts
>>>>>>> Ȟ.q0 ⟨Ȟ⟩ ⊢* H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* H.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>>>>>
>>>>>>> Of the infinite set of implementations of Ȟ every one that
>>>>>>> transitions
>>>>>>> to H.qy derives an answer consistent with the behavior of Ȟ.
>>>>>>>
>>>>>>> *Above machine adapted to become self-contradictory*
>>>>>>>
>>>>>>> // Linz Turing machine template Ĥ applied to ⟨Ĥ⟩
>>>>>>> // its own Turing Machine description
>>>>>>> // --- Does  Ĥ halt on ⟨Ĥ⟩ its own machine description?
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>>
>>>>>>> Of the infinite set of implementations of Ĥ none of them derives an
>>>>>>> answer consistent with the behavior of Ĥ.
>>>>>>>
>>>>>>
>>>>>> When the only difference between two machine templates is that
>>>>>> one is self-contradictory and the other is not and every
>>>>>> implementation of the self-contradictory template is undecidable
>>>>>
>>>>> Saying that a Turing machine is undecidable is a category error,
>>>>> like saying the number 5 is loud.
>>>>>
>>>> Every instance of Ĥ applied to ⟨Ĥ⟩ derives a machine
>>>> that does not correctly report its own behavior.
>>>>
>>>
>>> No Ĥ reports on anything's behavior.
>>
>> When Ĥ is a termination analyzer applied to its
>> own Turing Machine description and Ĥ always halts
>> then every Ĥ correctly reports the opposite of
>> its own behavior.
>>
>
> When Ĥ is a termination analyzer applied to its
> own Turing Machine description then every Ĥ never
> correctly reports on its own behavior.
>
>

When x is a natural number such that x=1-x then every x is a purple unicorn.