// Linz Turing machine H --- M applied to w
// --- Does M halt on w?
H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt

// Linz Turing machine H --- H applied to ⟨H⟩
// --- Do you halt on your own Turing Machine description ?
H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
*Correctly transitions to H.qy*

When we simply append an infinite loop to the above H.qy
then this transforms the above H applied to ⟨H⟩ ⟨H⟩ into
a self-contradictory question.

https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

On 20/02/24 02:02, polcot2 wrote:
> // Linz Turing machine H --- M applied to w
> // --- Does M halt on w?
> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>
> // Linz Turing machine H --- H applied to ⟨H⟩
> // --- Do you halt on your own Turing Machine description ?
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
> *Correctly transitions to H.qy*
>
> When we simply append an infinite loop to the above H.qy
> then this transforms the above H applied to ⟨H⟩ ⟨H⟩ into
> a self-contradictory question.
>
> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

The question is "self-contradictory" in the way that:
Every plugh xyzzys all plughs who do not xyzzy themselves.
Does a plugh exist?
is "self-contradictory".

The question is "self-contradictory" in the way that:
Which natural numbers are equal to themselves plus one?
is "self-contradictory".

On 2/19/24 8:02 PM, polcot2 wrote:
> // Linz Turing machine H --- M applied to w
> // --- Does M halt on w?
> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>
> // Linz Turing machine H --- H applied to ⟨H⟩
> // --- Do you halt on your own Turing Machine description ?

Except that isn't what you are doing below!!!!

So, you are just lying.

Below H is applied to (H) (H)

> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
> *Correctly transitions to H.qy*

Only if H applied to (H) will halt. Since that is asking it to determine
if H applied to -nothing- which is an invalid input, the question is
either invalid, or H must include the ability to determine if its input
is a valid computation.

If it does, the H.qy is correct for H (H) (H) as H (H) will also go to
qy as H - will go to qn and halt.

>
> When we simply append an infinite loop to the above H.qy
> then this transforms the above H applied to ⟨H⟩ ⟨H⟩ into
> a self-contradictory question.
>
> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

Except then the machine is no longer "H", and the input to the actual H
is no longer a description of itself. Note, Linz is careful to give his
modified machines new names and not think of them as just "version" of
the previous machine. They are a new machine.

Note, that the resultant H^, (when also adding the duplication of the
input needed to avoid the problem shown above) when applied to the
description of itself (H^) has a definite behavior, since it was built
on a SPECIFIC H, that has definite behavior.

IF H (H^) (H^) goes to qn as you have tried to claim is correct, then we
can show that H^ (H^) will also go to its qn and Halt, showing that H
was just wrong.

If we start with a DIFFERENT H (and thus get a DIFFERENT H^, and a
DIFFERENT question) that goes to qy when applied as H (H^) (H^) then we
can show that THIS H^ will also end at qy, and then to the infinite
loop, so it will never halt, and again, this different H is wrong.

In BOTH cases, there WAS a correct answer to the question "Does the
input represent a Halting Computation?", so the Halting question is
valid (as it always has a right answer).

Only your POOP question, which ignores that Computations have fixed
answers for given inputs becomes invalid.

On 2/19/2024 9:48 PM, Richard Damon wrote:
> On 2/19/24 8:02 PM, polcot2 wrote:
>> // Linz Turing machine H --- M applied to w
>> // --- Does M halt on w?
>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>
>> // Linz Turing machine H --- H applied to ⟨H⟩
>> // --- Do you halt on your own Turing Machine description ?
>
> Except that isn't what you are doing below!!!!
>
> So, you are just lying.
>
> Below H is applied to (H) (H)
>
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>> *Correctly transitions to H.qy*
>
> Only if H applied to (H) will halt. Since that is asking it to determine
> if H applied to -nothing- which is an invalid input, the question is
> either invalid, or H must include the ability to determine if its input
> is a valid computation.

Have you ever heard of a termination analyzer?

https://termination-portal.org/wiki/19th_International_Workshop_on_Termination

It is the same as a halt decider yet only has to get
at least one input correctly.

There exists an H such that it correctly determines
that itself halts on itself.

--
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/19/24 11:00 PM, olcott wrote:
> On 2/19/2024 9:48 PM, Richard Damon wrote:
>> On 2/19/24 8:02 PM, polcot2 wrote:
>>> // Linz Turing machine H --- M applied to w
>>> // --- Does M halt on w?
>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>
>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>> // --- Do you halt on your own Turing Machine description ?
>>
>> Except that isn't what you are doing below!!!!
>>
>> So, you are just lying.
>>
>> Below H is applied to (H) (H)
>>
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>> *Correctly transitions to H.qy*
>>
>> Only if H applied to (H) will halt. Since that is asking it to
>> determine if H applied to -nothing- which is an invalid input, the
>> question is either invalid, or H must include the ability to determine
>> if its input is a valid computation.
>
> Have you ever heard of a termination analyzer?
>
> https://termination-portal.org/wiki/19th_International_Workshop_on_Termination
>
> It is the same as a halt decider yet only has to get
> at least one input correctly.

So, isn't a Halt Deciddr.

>
> There exists an H such that it correctly determines
> that itself halts on itself.
>

So?

If H is a Halt decider, it should ALWAYS halt on any given input.

You just seem to have this problem of thinking that not-As are somehow As

On 2/19/2024 10:05 PM, Richard Damon wrote:
> On 2/19/24 11:00 PM, olcott wrote:
>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>> // Linz Turing machine H --- M applied to w
>>>> // --- Does M halt on w?
>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>
>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>> // --- Do you halt on your own Turing Machine description ?
>>>
>>> Except that isn't what you are doing below!!!!
>>>
>>> So, you are just lying.
>>>
>>> Below H is applied to (H) (H)
>>>
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>> *Correctly transitions to H.qy*
>>>
>>> Only if H applied to (H) will halt. Since that is asking it to
>>> determine if H applied to -nothing- which is an invalid input, the
>>> question is either invalid, or H must include the ability to
>>> determine if its input is a valid computation.
>>
>> Have you ever heard of a termination analyzer?

It does correctly determine its own halts status thus <is>
a halt decider on the domain of itself.

The fact that deciders cannot correctly decide self-contradictory
inputs does not limit computation any more than restricting the
ingredients to house bricks limits a baker from baking an angel
food cake.

>>
>> https://termination-portal.org/wiki/19th_International_Workshop_on_Termination
>>
>> It is the same as a halt decider yet only has to get
>> at least one input correctly.
>
> So, isn't a Halt Deciddr.
>>
>> There exists an H such that it correctly determines
>> that itself halts on itself.
>>
>
> So?
>
> If H is a Halt decider, it should ALWAYS halt on any given input.
>
> You just seem to have this problem of thinking that not-As are somehow As
>
>

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

On 20/02/24 05:15, olcott wrote:
> On 2/19/2024 10:05 PM, Richard Damon wrote:
>> On 2/19/24 11:00 PM, olcott wrote:
>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>> // Linz Turing machine H --- M applied to w
>>>>> // --- Does M halt on w?
>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>
>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>
>>>> Except that isn't what you are doing below!!!!
>>>>
>>>> So, you are just lying.
>>>>
>>>> Below H is applied to (H) (H)
>>>>
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>> *Correctly transitions to H.qy*
>>>>
>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>> determine if H applied to -nothing- which is an invalid input, the
>>>> question is either invalid, or H must include the ability to
>>>> determine if its input is a valid computation.
>>>
>>> Have you ever heard of a termination analyzer?
>
> It does correctly determine its own halts status thus <is>
> a halt decider on the domain of itself.

That is not the definition of a halt decider. Try again.

On 20/02/24 05:00, olcott wrote:
> On 2/19/2024 9:48 PM, Richard Damon wrote:
>> On 2/19/24 8:02 PM, polcot2 wrote:
>>> // Linz Turing machine H --- M applied to w
>>> // --- Does M halt on w?
>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>
>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>> // --- Do you halt on your own Turing Machine description ?
>>
>> Except that isn't what you are doing below!!!!
>>
>> So, you are just lying.
>>
>> Below H is applied to (H) (H)
>>
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>> *Correctly transitions to H.qy*
>>
>> Only if H applied to (H) will halt. Since that is asking it to
>> determine if H applied to -nothing- which is an invalid input, the
>> question is either invalid, or H must include the ability to determine
>> if its input is a valid computation.
>
> Have you ever heard of a termination analyzer?

int H(string P, string I) {return 0;} // <- termination analyzer?

it still doesn't get the counterexample correct, by the way.

>
> https://termination-portal.org/wiki/19th_International_Workshop_on_Termination

16:00 Fabian Mitterwallner, Aart Middeldorp and René Thiemann:

Linear Termination over N is Undecidable (paper)

If one specific type of termination is undecidable how can you pretend
that all Turing machne termination is decidable?

On 2/19/2024 10:39 PM, immibis wrote:
> On 20/02/24 05:15, olcott wrote:
>> On 2/19/2024 10:05 PM, Richard Damon wrote:
>>> On 2/19/24 11:00 PM, olcott wrote:
>>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>>> // Linz Turing machine H --- M applied to w
>>>>>> // --- Does M halt on w?
>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>>
>>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>>
>>>>> Except that isn't what you are doing below!!!!
>>>>>
>>>>> So, you are just lying.
>>>>>
>>>>> Below H is applied to (H) (H)
>>>>>
>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>>> *Correctly transitions to H.qy*
>>>>>
>>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>>> determine if H applied to -nothing- which is an invalid input, the
>>>>> question is either invalid, or H must include the ability to
>>>>> determine if its input is a valid computation.
>>>>
>>>> Have you ever heard of a termination analyzer?
>>
>> It does correctly determine its own halts status thus <is>
>> a halt decider on the domain of itself.
>
> That is not the definition of a halt decider. Try again.
>

All of modern work is done on termination analysis where progress
is valued and perfection is not required.

*H applied to ⟨H⟩ ⟨H⟩ correctly transitions to H.qy*

--
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/19/2024 11:08 PM, immibis wrote:
> On 20/02/24 05:00, olcott wrote:
>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>> // Linz Turing machine H --- M applied to w
>>>> // --- Does M halt on w?
>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>
>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>> // --- Do you halt on your own Turing Machine description ?
>>>
>>> Except that isn't what you are doing below!!!!
>>>
>>> So, you are just lying.
>>>
>>> Below H is applied to (H) (H)
>>>
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>> *Correctly transitions to H.qy*
>>>
>>> Only if H applied to (H) will halt. Since that is asking it to
>>> determine if H applied to -nothing- which is an invalid input, the
>>> question is either invalid, or H must include the ability to
>>> determine if its input is a valid computation.
>>
>> Have you ever heard of a termination analyzer?
>
> int H(string P, string I) {return 0;} // <- termination analyzer?
>
> it still doesn't get the counterexample correct, by the way.

The only reason that it does not get the counter-example right
is isomorphic to this question:
Is this sentence true or false: "This sentence is not true." ?

The same way that ZFC abolished Russell's Paradox can be applied
to the halting problem counter-example input.

>
>>
>> https://termination-portal.org/wiki/19th_International_Workshop_on_Termination
>
> 16:00     Fabian Mitterwallner, Aart Middeldorp and René Thiemann:
>
> Linear Termination over N is Undecidable (paper)
>
> If one specific type of termination is undecidable how can you pretend
> that all Turing machne termination is decidable?

--
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/19/24 11:15 PM, olcott wrote:
> On 2/19/2024 10:05 PM, Richard Damon wrote:
>> On 2/19/24 11:00 PM, olcott wrote:
>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>> // Linz Turing machine H --- M applied to w
>>>>> // --- Does M halt on w?
>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>
>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>
>>>> Except that isn't what you are doing below!!!!
>>>>
>>>> So, you are just lying.
>>>>
>>>> Below H is applied to (H) (H)
>>>>
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>> *Correctly transitions to H.qy*
>>>>
>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>> determine if H applied to -nothing- which is an invalid input, the
>>>> question is either invalid, or H must include the ability to
>>>> determine if its input is a valid computation.
>>>
>>> Have you ever heard of a termination analyzer?
>
> It does correctly determine its own halts status thus <is>
> a halt decider on the domain of itself.

So?

That just shows you don't understand what you are talking about.

>
> The fact that deciders cannot correctly decide self-contradictory
> inputs does not limit computation any more than restricting the
> ingredients to house bricks limits a baker from baking an angel
> food cake.

So, you think you CAN bake a angel food cake out of bricks?

If it doesn't "limit" the bakers ability, and without that limit he
could do it, then with the limit he still can!

I guess you are just failing at English comprehension.

>
>>>
>>> https://termination-portal.org/wiki/19th_International_Workshop_on_Termination
>>>
>>> It is the same as a halt decider yet only has to get
>>> at least one input correctly.
>>
>> So, isn't a Halt Deciddr.
>>>
>>> There exists an H such that it correctly determines
>>> that itself halts on itself.
>>>
>>
>> So?
>>
>> If H is a Halt decider, it should ALWAYS halt on any given input.
>>
>> You just seem to have this problem of thinking that not-As are somehow As
>>
>>
>

On 2/20/24 12:08 AM, olcott wrote:
> On 2/19/2024 10:39 PM, immibis wrote:
>> On 20/02/24 05:15, olcott wrote:
>>> On 2/19/2024 10:05 PM, Richard Damon wrote:
>>>> On 2/19/24 11:00 PM, olcott wrote:
>>>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>> // --- Does M halt on w?
>>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>>>
>>>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>>>
>>>>>> Except that isn't what you are doing below!!!!
>>>>>>
>>>>>> So, you are just lying.
>>>>>>
>>>>>> Below H is applied to (H) (H)
>>>>>>
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>>>> *Correctly transitions to H.qy*
>>>>>>
>>>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>>>> determine if H applied to -nothing- which is an invalid input, the
>>>>>> question is either invalid, or H must include the ability to
>>>>>> determine if its input is a valid computation.
>>>>>
>>>>> Have you ever heard of a termination analyzer?
>>>
>>> It does correctly determine its own halts status thus <is>
>>> a halt decider on the domain of itself.
>>
>> That is not the definition of a halt decider. Try again.
>>
>
> All of modern work is done on termination analysis where progress
> is valued and perfection is not required.
>
> *H applied to ⟨H⟩ ⟨H⟩ correctly transitions to H.qy*
>

In other words, you are admitting you are LYING by misusing the term.

There you go Donnie.

On 2024-02-20 01:02:42 +0000, polcot2 said:

> // Linz Turing machine H --- M applied to w
> // --- Does M halt on w?
> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>
> // Linz Turing machine H --- H applied to ⟨H⟩
> // --- Do you halt on your own Turing Machine description ?
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
> *Correctly transitions to H.qy*
>
> When we simply append an infinite loop to the above H.qy
> then this transforms the above H applied to ⟨H⟩ ⟨H⟩ into
> a self-contradictory question.

That you can think that you can convert something to
a sellf-contradictory quesstion proves that it is not
self-contradictory.

--
Mikko

On 2/20/2024 6:34 AM, Richard Damon wrote:
> On 2/19/24 11:15 PM, olcott wrote:
>> On 2/19/2024 10:05 PM, Richard Damon wrote:
>>> On 2/19/24 11:00 PM, olcott wrote:
>>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>>> // Linz Turing machine H --- M applied to w
>>>>>> // --- Does M halt on w?
>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>>
>>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>>
>>>>> Except that isn't what you are doing below!!!!
>>>>>
>>>>> So, you are just lying.
>>>>>
>>>>> Below H is applied to (H) (H)
>>>>>
>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>>> *Correctly transitions to H.qy*
>>>>>
>>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>>> determine if H applied to -nothing- which is an invalid input, the
>>>>> question is either invalid, or H must include the ability to
>>>>> determine if its input is a valid computation.
>>>>
>>>> Have you ever heard of a termination analyzer?
>>
>> It does correctly determine its own halts status thus <is>
>> a halt decider on the domain of itself.
>
> So?
>
> That just shows you don't understand what you are talking about.
>
>>
>> The fact that deciders cannot correctly decide self-contradictory
>> inputs does not limit computation any more than restricting the
>> ingredients to house bricks limits a baker from baking an angel
>> food cake.
>
>
> So, you think you CAN bake a angel food cake out of bricks?
>

Just like my simplification of Tarski's Undefinability Proof:
Boolean True(English, "This sentence is not true.")

The requirement for a truth predicate / halt decider to decide
self-contradictory inputs is isomorphic to requiring a baker
to use only house bricks for ingredients.

*Alan Turing's Halting Problem is incorrectly formed* (PART-TWO) sci.logic
*On 6/20/2004 11:31 AM, Peter Olcott wrote*
> PREMISES:
> (1) The Halting Problem was specified in such a way that a solution
> was defined to be impossible.
>
> (2) The set of questions that are defined to not have any possible
> correct answer(s) forms a proper subset of all possible questions.
> …
> CONCLUSION:
> Therefore the Halting Problem is an ill-formed question.
>
USENET Message-ID:
<kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>

> If it doesn't "limit" the bakers ability, and without that limit he
> could do it, then with the limit he still can!
>
> I guess you are just failing at English comprehension.
>
>>
>>>>
>>>> https://termination-portal.org/wiki/19th_International_Workshop_on_Termination
>>>>
>>>> It is the same as a halt decider yet only has to get
>>>> at least one input correctly.
>>>
>>> So, isn't a Halt Deciddr.
>>>>
>>>> There exists an H such that it correctly determines
>>>> that itself halts on itself.
>>>>
>>>
>>> So?
>>>
>>> If H is a Halt decider, it should ALWAYS halt on any given input.
>>>
>>> You just seem to have this problem of thinking that not-As are
>>> somehow As
>>>
>>>
>>
>

--
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/20/2024 6:34 AM, Richard Damon wrote:
> On 2/20/24 12:08 AM, olcott wrote:
>> On 2/19/2024 10:39 PM, immibis wrote:
>>> On 20/02/24 05:15, olcott wrote:
>>>> On 2/19/2024 10:05 PM, Richard Damon wrote:
>>>>> On 2/19/24 11:00 PM, olcott wrote:
>>>>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>>> // --- Does M halt on w?
>>>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>>>>
>>>>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>>>>
>>>>>>> Except that isn't what you are doing below!!!!
>>>>>>>
>>>>>>> So, you are just lying.
>>>>>>>
>>>>>>> Below H is applied to (H) (H)
>>>>>>>
>>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>>>>> *Correctly transitions to H.qy*
>>>>>>>
>>>>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>>>>> determine if H applied to -nothing- which is an invalid input,
>>>>>>> the question is either invalid, or H must include the ability to
>>>>>>> determine if its input is a valid computation.
>>>>>>
>>>>>> Have you ever heard of a termination analyzer?
>>>>
>>>> It does correctly determine its own halts status thus <is>
>>>> a halt decider on the domain of itself.
>>>
>>> That is not the definition of a halt decider. Try again.
>>>
>>
>> All of modern work is done on termination analysis where progress
>> is valued and perfection is not required.
>>
>> *H applied to ⟨H⟩ ⟨H⟩ correctly transitions to H.qy*
>>
>
> In other words, you are admitting you are LYING by misusing the term.
>
> There you go Donnie.

The above H is a correct termination analyzer on itself as input.
When the above H is transformed into a self-contradictory input
by appending an infinite loop to the H.qy state then:

Do you halt on your own Turing Machine description ?
becomes a self-contradictory question.
Before this infinite loop was appended the correct answer was YES.

--
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/20/2024 7:57 AM, Mikko wrote:
> On 2024-02-20 01:02:42 +0000, polcot2 said:
>
>> // Linz Turing machine H --- M applied to w
>> // --- Does M halt on w?
>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>
>> // Linz Turing machine H --- H applied to ⟨H⟩
>> // --- Do you halt on your own Turing Machine description ?
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>> *Correctly transitions to H.qy*
>>
>> When we simply append an infinite loop to the above H.qy
>> then this transforms the above H applied to ⟨H⟩ ⟨H⟩ into
>> a self-contradictory question.
>
> That you can think that you can convert something to
> a sellf-contradictory quesstion proves that it is not
> self-contradictory.
>

WRONG !!!
"This sentence is true." Is not self-contradictory.
"This sentence is NOT true." Is 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 20/02/24 06:08, olcott wrote:
> On 2/19/2024 10:39 PM, immibis wrote:
>> On 20/02/24 05:15, olcott wrote:
>>> On 2/19/2024 10:05 PM, Richard Damon wrote:
>>>> On 2/19/24 11:00 PM, olcott wrote:
>>>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>> // --- Does M halt on w?
>>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>>>
>>>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>>>
>>>>>> Except that isn't what you are doing below!!!!
>>>>>>
>>>>>> So, you are just lying.
>>>>>>
>>>>>> Below H is applied to (H) (H)
>>>>>>
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>>>> *Correctly transitions to H.qy*
>>>>>>
>>>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>>>> determine if H applied to -nothing- which is an invalid input, the
>>>>>> question is either invalid, or H must include the ability to
>>>>>> determine if its input is a valid computation.
>>>>>
>>>>> Have you ever heard of a termination analyzer?
>>>
>>> It does correctly determine its own halts status thus <is>
>>> a halt decider on the domain of itself.
>>
>> That is not the definition of a halt decider. Try again.
>>
>
> All of modern work is done on termination analysis where progress
> is valued and perfection is not required.

So it is irrelevant to the halting problem.

On 20/02/24 15:14, olcott wrote:
> On 2/20/2024 6:34 AM, Richard Damon wrote:
>> On 2/20/24 12:08 AM, olcott wrote:
>>> On 2/19/2024 10:39 PM, immibis wrote:
>>>> On 20/02/24 05:15, olcott wrote:
>>>>> On 2/19/2024 10:05 PM, Richard Damon wrote:
>>>>>> On 2/19/24 11:00 PM, olcott wrote:
>>>>>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>>>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>>>> // --- Does M halt on w?
>>>>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>>>>>
>>>>>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>>>>>
>>>>>>>> Except that isn't what you are doing below!!!!
>>>>>>>>
>>>>>>>> So, you are just lying.
>>>>>>>>
>>>>>>>> Below H is applied to (H) (H)
>>>>>>>>
>>>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>>>>>> *Correctly transitions to H.qy*
>>>>>>>>
>>>>>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>>>>>> determine if H applied to -nothing- which is an invalid input,
>>>>>>>> the question is either invalid, or H must include the ability to
>>>>>>>> determine if its input is a valid computation.
>>>>>>>
>>>>>>> Have you ever heard of a termination analyzer?
>>>>>
>>>>> It does correctly determine its own halts status thus <is>
>>>>> a halt decider on the domain of itself.
>>>>
>>>> That is not the definition of a halt decider. Try again.
>>>>
>>>
>>> All of modern work is done on termination analysis where progress
>>> is valued and perfection is not required.
>>>
>>> *H applied to ⟨H⟩ ⟨H⟩ correctly transitions to H.qy*
>>>
>>
>> In other words, you are admitting you are LYING by misusing the term.
>>
>> There you go Donnie.
>
> The above H is a correct termination analyzer on itself as input.
> When the above H is transformed into a self-contradictory input
> by appending an infinite loop to the H.qy state then:

then it becomes not a correct termination analyzer on itself as input

On 20/02/24 15:09, olcott wrote:
> On 2/20/2024 6:34 AM, Richard Damon wrote:
>> On 2/19/24 11:15 PM, olcott wrote:
>>> On 2/19/2024 10:05 PM, Richard Damon wrote:
>>>> On 2/19/24 11:00 PM, olcott wrote:
>>>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>> // --- Does M halt on w?
>>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>>>
>>>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>>>
>>>>>> Except that isn't what you are doing below!!!!
>>>>>>
>>>>>> So, you are just lying.
>>>>>>
>>>>>> Below H is applied to (H) (H)
>>>>>>
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>>>> *Correctly transitions to H.qy*
>>>>>>
>>>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>>>> determine if H applied to -nothing- which is an invalid input, the
>>>>>> question is either invalid, or H must include the ability to
>>>>>> determine if its input is a valid computation.
>>>>>
>>>>> Have you ever heard of a termination analyzer?
>>>
>>> It does correctly determine its own halts status thus <is>
>>> a halt decider on the domain of itself.
>>
>> So?
>>
>> That just shows you don't understand what you are talking about.
>>
>>>
>>> The fact that deciders cannot correctly decide self-contradictory
>>> inputs does not limit computation any more than restricting the
>>> ingredients to house bricks limits a baker from baking an angel
>>> food cake.
>>
>>
>> So, you think you CAN bake a angel food cake out of bricks?
>>
>
> Just like my simplification of Tarski's Undefinability Proof: > Boolean True(English, "This sentence is not true.")

Simplification is useless if it does not correspond to something
unsimplified. Was Tarski not talking about languages of mathematical
logic? They don't have any way to say "this sentence".

On 20/02/24 06:15, olcott wrote:
> On 2/19/2024 11:08 PM, immibis wrote:
>> On 20/02/24 05:00, olcott wrote:
>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>> // Linz Turing machine H --- M applied to w
>>>>> // --- Does M halt on w?
>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>
>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>
>>>> Except that isn't what you are doing below!!!!
>>>>
>>>> So, you are just lying.
>>>>
>>>> Below H is applied to (H) (H)
>>>>
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>> *Correctly transitions to H.qy*
>>>>
>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>> determine if H applied to -nothing- which is an invalid input, the
>>>> question is either invalid, or H must include the ability to
>>>> determine if its input is a valid computation.
>>>
>>> Have you ever heard of a termination analyzer?
>>
>> int H(string P, string I) {return 0;} // <- termination analyzer?
>>
>> it still doesn't get the counterexample correct, by the way.
>
> The only reason that it does not get the counter-example right
> is isomorphic to this question:
> Is this sentence true or false: "This sentence is not true." ?

So you agree it does not get the counter-example right, therefore it's
not a halting decider. Halting deciders get all halting questions right,
including self-contradictory ones.

> The same way that ZFC abolished Russell's Paradox can be applied
> to the halting problem counter-example input.

So how would you modify the rules to make it invalid? Would you say that
the machine H-hat doesn't have a representation? Or would you say that
machine H-hat's representation is never allowed to occur on a Turing
machine tape? Or something else?

On 2/20/24 9:14 AM, olcott wrote:
> On 2/20/2024 6:34 AM, Richard Damon wrote:
>> On 2/20/24 12:08 AM, olcott wrote:
>>> On 2/19/2024 10:39 PM, immibis wrote:
>>>> On 20/02/24 05:15, olcott wrote:
>>>>> On 2/19/2024 10:05 PM, Richard Damon wrote:
>>>>>> On 2/19/24 11:00 PM, olcott wrote:
>>>>>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>>>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>>>> // --- Does M halt on w?
>>>>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>>>>>
>>>>>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>>>>>
>>>>>>>> Except that isn't what you are doing below!!!!
>>>>>>>>
>>>>>>>> So, you are just lying.
>>>>>>>>
>>>>>>>> Below H is applied to (H) (H)
>>>>>>>>
>>>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>>>>>> *Correctly transitions to H.qy*
>>>>>>>>
>>>>>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>>>>>> determine if H applied to -nothing- which is an invalid input,
>>>>>>>> the question is either invalid, or H must include the ability to
>>>>>>>> determine if its input is a valid computation.
>>>>>>>
>>>>>>> Have you ever heard of a termination analyzer?
>>>>>
>>>>> It does correctly determine its own halts status thus <is>
>>>>> a halt decider on the domain of itself.
>>>>
>>>> That is not the definition of a halt decider. Try again.
>>>>
>>>
>>> All of modern work is done on termination analysis where progress
>>> is valued and perfection is not required.
>>>
>>> *H applied to ⟨H⟩ ⟨H⟩ correctly transitions to H.qy*
>>>
>>
>> In other words, you are admitting you are LYING by misusing the term.
>>
>> There you go Donnie.
>
> The above H is a correct termination analyzer on itself as input.
> When the above H is transformed into a self-contradictory input
> by appending an infinite loop to the H.qy state then:
>
> Do you halt on your own Turing Machine description ?
> becomes a self-contradictory question.
> Before this infinite loop was appended the correct answer was YES.
>

But it isn't a "Halt Decider" per the definition.

So, either you are admitting defeat on the ability to refute the Halting
Problem proof, or you are admitting that you are lying about refuting
the Halting Problem proof.

Part of the problem is that you begin by perverting the Halting QUestion
into a Strawman, which is just as wrong as the kiddie porn you were
caught with a few years ago, as as wrong as your claim that it was ok
because you were God.

I wonder if you got the case dismissed because you were found
incompetent to stand trial due to your mental instability.

On 2/20/24 9:09 AM, olcott wrote:
> On 2/20/2024 6:34 AM, Richard Damon wrote:
>> On 2/19/24 11:15 PM, olcott wrote:
>>> On 2/19/2024 10:05 PM, Richard Damon wrote:
>>>> On 2/19/24 11:00 PM, olcott wrote:
>>>>> On 2/19/2024 9:48 PM, Richard Damon wrote:
>>>>>> On 2/19/24 8:02 PM, polcot2 wrote:
>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>> // --- Does M halt on w?
>>>>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>>>>
>>>>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>>>>> // --- Do you halt on your own Turing Machine description ?
>>>>>>
>>>>>> Except that isn't what you are doing below!!!!
>>>>>>
>>>>>> So, you are just lying.
>>>>>>
>>>>>> Below H is applied to (H) (H)
>>>>>>
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>>>>> *Correctly transitions to H.qy*
>>>>>>
>>>>>> Only if H applied to (H) will halt. Since that is asking it to
>>>>>> determine if H applied to -nothing- which is an invalid input, the
>>>>>> question is either invalid, or H must include the ability to
>>>>>> determine if its input is a valid computation.
>>>>>
>>>>> Have you ever heard of a termination analyzer?
>>>
>>> It does correctly determine its own halts status thus <is>
>>> a halt decider on the domain of itself.
>>
>> So?
>>
>> That just shows you don't understand what you are talking about.
>>
>>>
>>> The fact that deciders cannot correctly decide self-contradictory
>>> inputs does not limit computation any more than restricting the
>>> ingredients to house bricks limits a baker from baking an angel
>>> food cake.
>>
>>
>> So, you think you CAN bake a angel food cake out of bricks?
>>
>
> Just like my simplification of Tarski's Undefinability Proof:
> Boolean True(English, "This sentence is not true.")

You mean you LIES.

>
> The requirement for a truth predicate / halt decider to decide
> self-contradictory inputs is isomorphic to requiring a baker
> to use only house bricks for ingredients.

Which isn't what he did, just your misunderstanding of it.

>
> *Alan Turing's Halting Problem is incorrectly formed* (PART-TWO)  sci.logic
> *On 6/20/2004 11:31 AM, Peter Olcott wrote*
> > PREMISES:
> > (1) The Halting Problem was specified in such a way that a solution
> > was defined to be impossible.
> >
> > (2) The set of questions that are defined to not have any possible
> > correct answer(s) forms a proper subset of all possible questions.
> > …
> > CONCLUSION:
> > Therefore the Halting Problem is an ill-formed question.
> >
> USENET Message-ID:
> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>

You are just proving your total ignorance of what you are talking about.

On 2/20/24 9:24 AM, olcott wrote:
> On 2/20/2024 7:57 AM, Mikko wrote:
>> On 2024-02-20 01:02:42 +0000, polcot2 said:
>>
>>> // Linz Turing machine H --- M applied to w
>>> // --- Does M halt on w?
>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>
>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>> // --- Do you halt on your own Turing Machine description ?
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>> *Correctly transitions to H.qy*
>>>
>>> When we simply append an infinite loop to the above H.qy
>>> then this transforms the above H applied to ⟨H⟩ ⟨H⟩ into
>>> a self-contradictory question.
>>
>> That you can think that you can convert something to
>> a sellf-contradictory quesstion proves that it is not
>> self-contradictory.
>>
>
> WRONG !!!
> "This sentence is true." Is not self-contradictory.
> "This sentence is NOT true." Is self-contradictory.
>

Which is all just Red Herring, as the original sentence isn't
self-contradictory as it doesn't even "reference" itself.

You are just proving you don't understand what "identity" is about.

You think two things that are different, can be the same thing, which
just proves your insanity.

On 2024-02-20 14:24:19 +0000, olcott said:

> On 2/20/2024 7:57 AM, Mikko wrote:
>> On 2024-02-20 01:02:42 +0000, polcot2 said:
>>
>>> // Linz Turing machine H --- M applied to w
>>> // --- Does M halt on w?
>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>
>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>> // --- Do you halt on your own Turing Machine description ?
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>> *Correctly transitions to H.qy*
>>>
>>> When we simply append an infinite loop to the above H.qy
>>> then this transforms the above H applied to ⟨H⟩ ⟨H⟩ into
>>> a self-contradictory question.
>>
>> That you can think that you can convert something to
>> a sellf-contradictory quesstion proves that it is not
>> self-contradictory.
>>
>
> WRONG !!!

Nothing wrong at all, on the contrary, a good example to demonstrate
what "conversion to aself contradictory questiion" really means:

> "This sentence is true." Is not self-contradictory.
> "This sentence is NOT true." Is self-contradictory.

--
Mikko

On 2/21/2024 4:31 AM, Mikko wrote:
> On 2024-02-20 14:24:19 +0000, olcott said:
>
>> On 2/20/2024 7:57 AM, Mikko wrote:
>>> On 2024-02-20 01:02:42 +0000, polcot2 said:
>>>
>>>> // Linz Turing machine H --- M applied to w
>>>> // --- Does M halt on w?
>>>> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
>>>> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
>>>>
>>>> // Linz Turing machine H --- H applied to ⟨H⟩
>>>> // --- Do you halt on your own Turing Machine description ?
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy   // H applied to ⟨H⟩ halts
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn   // H applied to ⟨H⟩ does not halt
>>>> *Correctly transitions to H.qy*
>>>>
>>>> When we simply append an infinite loop to the above H.qy
>>>> then this transforms the above H applied to ⟨H⟩ ⟨H⟩ into
>>>> a self-contradictory question.
>>>
>>> That you can think that you can convert something to
>>> a sellf-contradictory quesstion proves that it is not
>>> self-contradictory.
>>>
>>
>> WRONG !!!
>
> Nothing wrong at all, on the contrary, a good example to demonstrate
> what "conversion to aself contradictory questiion" really means:
>
>> "This sentence is true." Is not self-contradictory.
>> "This sentence is NOT true." Is self-contradictory.
>

Is this sentence true or false: "This sentence is NOT true." ?
*Both TRUE and FALSE are the wrong answer*

// Linz Turing machine H --- H applied to ⟨H⟩
H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
Do you halt on your own Turing Machine description ?
*YES*

When we append an infinite loop to the H.qy state we derive Ȟ

Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
H.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
Do you halt on your own Turing Machine description ?
*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