// Linz Turing machine H --- M applied to w
// --- Does M halts 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

Linz H' is merely the self-contradictory form of Linz H applied to ⟨H⟩

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

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

On 2024-02-16 06:07:04 +0000, olcott said:

> // Linz Turing machine H --- M applied to w
> // --- Does M halts 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

What does H applied to <H> mean? H requires two argumlents.
Do you mean that the unspecified second argument is the empty tape?
Linz always specifies both arguments of H.

--
Mikko

Mikko <mikko.levanto@iki.fi> writes:

> On 2024-02-16 06:07:04 +0000, olcott said:
>
>> // Linz Turing machine H --- M applied to w
>> // --- Does M halts 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
>
> What does H applied to <H> mean? H requires two argumlents.
> Do you mean that the unspecified second argument is the empty tape?
> Linz always specifies both arguments of H.

Turing machines don't have "arguments" -- there is just a tape.
Personally, I would prefer a bit more rigour with an explicit notation
for the encoding of a pair[1], but Linz is outlining this proof only
because is has some historical interest.

In fact there's nothing wrong with the second to last comment. It's
just stating the conditions under which that line applies. It's the
condition from the first part (the "specification" of H) with H in place
if M, and <H> in place of w. What is has to do with anything, though,
is anyone's guess.

PO steadfastly refused (and probably still does refuse) to give those
two conditions for the actual tape given in the proof because they are
the ones that show that the specification of H can't be fulfilled:

H^.q0 <H^> |-* H.q0 <H^> <H^> |-* oo

if H^ applied to H^ halts (!!) and

H^.q0 <H^> |-* H.q0 <H^> <H^> |-* H.qn

if H^ applied to H^ does not halt (!!).

[1] There are other ways to be rigorous, of course. Chaitin uses self
delimiting encodings (I think), but way back when I thought it might be
worth while I wrote out the proof for PO using [M] for the string
encoding the machine M and <x, y> for the string encoding the pair or
strings x and y. It didn't help.

--
Ben.

On 2/16/2024 5:43 AM, Ben Bacarisse wrote:
> Mikko <mikko.levanto@iki.fi> writes:
>
>> On 2024-02-16 06:07:04 +0000, olcott said:
>>
>>> // Linz Turing machine H --- M applied to w
>>> // --- Does M halts 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
>>
>> What does H applied to <H> mean? H requires two argumlents.
>> Do you mean that the unspecified second argument is the empty tape?
>> Linz always specifies both arguments of H.
>
> Turing machines don't have "arguments" -- there is just a tape.
> Personally, I would prefer a bit more rigour with an explicit notation
> for the encoding of a pair[1], but Linz is outlining this proof only
> because is has some historical interest.
>
> In fact there's nothing wrong with the second to last comment. It's
> just stating the conditions under which that line applies. It's the
> condition from the first part (the "specification" of H) with H in place
> if M, and <H> in place of w. What is has to do with anything, though,
> is anyone's guess.
>

Pointing out an example of self-reference that can be easily transformed
to be isomorphic to the Liar Paradox.

> PO steadfastly refused (and probably still does refuse) to give those
> two conditions for the actual tape given in the proof because they are
> the ones that show that the specification of H can't be fulfilled:
>

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

> H^.q0 <H^> |-* H.q0 <H^> <H^> |-* oo
>
> if H^ applied to H^ halts (!!) and
>
> H^.q0 <H^> |-* H.q0 <H^> <H^> |-* H.qn
>
> if H^ applied to H^ does not halt (!!).
>
> [1] There are other ways to be rigorous, of course. Chaitin uses self
> delimiting encodings (I think), but way back when I thought it might be
> worth while I wrote out the proof for PO using [M] for the string
> encoding the machine M and <x, y> for the string encoding the pair or
> strings x and y. It didn't help.
>

--
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/16/24 1:07 AM, olcott wrote:
> // Linz Turing machine H --- M applied to w
> // --- Does M halts 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

Right, this is the defined behavior of H, if it is correct.

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

But H applied to (H) (H) is asking about the behavior of H applied to
(H) which is asking about the behavior of H applied to nothing, which
ends up being an input outside the defined space. Depending on your
exact set of definitions H applied to nothing might have no requirements
on its behavior, or it might be required to halt in qn, since its input
is NOT a description of a halting computtion (being not a computation at
all), which means that H applied to (H) will see a halting computation
and thus needs to halt in qy, and thus H applied to (H) (H) will halt in qy,

>
> Linz H' is merely the self-contradictory form of Linz H applied to ⟨H⟩
>
> // 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
>

But Ĥ isn't being asked to answer, H is. Wrapping H doesn't change who
is responsible to coming up with the right answer.

And since for every H we might design, the answer it gives will be wrong
for that problem (but every one of those problems HAS a correct answer,
the one H didn't give) we can conclude that no H can exist that meets
the requirements, and thus the Halting Problem in uncomputable, but
still a valid question to ask.

On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:

> Mikko <mikko.levanto@iki.fi> writes:
>
>> On 2024-02-16 06:07:04 +0000, olcott said:
>>
>>> // Linz Turing machine H --- M applied to w
>>> // --- Does M halts 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
>>
>> What does H applied to <H> mean? H requires two argumlents.
>> Do you mean that the unspecified second argument is the empty tape?
>> Linz always specifies both arguments of H.
>
> Turing machines don't have "arguments" -- there is just a tape.
> Personally, I would prefer a bit more rigour with an explicit notation
> for the encoding of a pair[1], but Linz is outlining this proof only
> because is has some historical interest.

When discussing a Turing machine it may be practical to call the
initial tape content a sequence of arguments if the problem
specification specifies the input as a combination of separately
defined parts.

> In fact there's nothing wrong with the second to last comment.

You mean "H applied to <H>" instead of "H applied to <H> <H>"?

--
Mikko

On 2/16/2024 11:48 AM, Mikko wrote:
> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>
>> Mikko <mikko.levanto@iki.fi> writes:
>>
>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>
>>>> // Linz Turing machine H --- M applied to w
>>>> // --- Does M halts 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
>>>
>>> What does H applied to <H> mean? H requires two argumlents.
>>> Do you mean that the unspecified second argument is the empty tape?
>>> Linz always specifies both arguments of H.
>>
>> Turing machines don't have "arguments" -- there is just a tape.
>> Personally, I would prefer a bit more rigour with an explicit notation
>> for the encoding of a pair[1], but Linz is outlining this proof only
>> because is has some historical interest.
>
> When discussing a Turing machine it may be practical to call the
> initial tape content a sequence of arguments if the problem
> specification specifies the input as a combination of separately
> defined parts.
>
>> In fact there's nothing wrong with the second to last comment.
>
> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>

It was less confusing when I did the Linz transformations
in reverse order, prepending the copy input states to Linz H
thus forming Olcott Ȟ

// Olcott Turing machine Ȟ --- Ȟ applied to ⟨Ȟ⟩ its own description
// --- Do you halt on your own Turing Machine Description?
Ȟ.q0 ⟨Ȟ⟩ ⊢* embedded_H ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ĥ.qy // Ȟ applied to ⟨Ȟ⟩ halts
Ȟ.q0 ⟨Ȟ⟩ ⊢* embedded_H ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ĥ.qn // Ȟ applied to ⟨Ȟ⟩ does not halt
Ȟ applied to ⟨Ȟ⟩ simply correctly transitions to Ĥ.qy

Linz Turing machine Ĥ applied to ⟨Ĥ⟩ is the self-contradictory form of
Olcott Turing machine Ȟ applied to ⟨Ȟ⟩

// Linz Turing machine Ĥ --- Ĥ applied to ⟨Ĥ⟩ its own description
// --- Do you halt on your own Turing Machine Description?
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
Ĥ applied to ⟨Ĥ⟩ cannot correctly transition to Ĥ.qy or Ĥ.qn
because Ĥ applied to ⟨Ĥ⟩ 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 2024-02-16 18:00:52 +0000, olcott said:

> On 2/16/2024 11:48 AM, Mikko wrote:
>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>
>>> Mikko <mikko.levanto@iki.fi> writes:
>>>
>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>
>>>>> // Linz Turing machine H --- M applied to w
>>>>> // --- Does M halts 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
>>>>
>>>> What does H applied to <H> mean? H requires two argumlents.
>>>> Do you mean that the unspecified second argument is the empty tape?
>>>> Linz always specifies both arguments of H.
>>>
>>> Turing machines don't have "arguments" -- there is just a tape.
>>> Personally, I would prefer a bit more rigour with an explicit notation
>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>> because is has some historical interest.
>>
>> When discussing a Turing machine it may be practical to call the
>> initial tape content a sequence of arguments if the problem
>> specification specifies the input as a combination of separately
>> defined parts.
>>
>>> In fact there's nothing wrong with the second to last comment.
>>
>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>
> It was less confusing when I did the Linz transformations
> in reverse order, prepending the copy input states to Linz H
> thus forming Olcott Ȟ

The symbol Ȟ looks too similar to Ĥ and can therefore be confusing.
You should use something clearer, e.g., H⁺. In any case, as it is
not defined by Linz, you should define it every time you use it.

--
Mikko

On 2/16/2024 12:21 PM, Mikko wrote:
> On 2024-02-16 18:00:52 +0000, olcott said:
>
>> On 2/16/2024 11:48 AM, Mikko wrote:
>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>
>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>
>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>
>>>>>> // Linz Turing machine H --- M applied to w
>>>>>> // --- Does M halts 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
>>>>>
>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>> Linz always specifies both arguments of H.
>>>>
>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>> Personally, I would prefer a bit more rigour with an explicit notation
>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>> because is has some historical interest.
>>>
>>> When discussing a Turing machine it may be practical to call the
>>> initial tape content a sequence of arguments if the problem
>>> specification specifies the input as a combination of separately
>>> defined parts.
>>>
>>>> In fact there's nothing wrong with the second to last comment.
>>>
>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>
>> It was less confusing when I did the Linz transformations
>> in reverse order, prepending the copy input states to Linz H
>> thus forming Olcott Ȟ
>
> The symbol Ȟ looks too similar to Ĥ and can therefore be confusing.
> You should use something clearer, e.g., H⁺. In any case, as it is
> not defined by Linz, you should define it every time you use it.
>

I am merely making the Linz transformations to the Linz H in
reverse order so that I can apply the Linz H to its own machine
description <H> with clean syntax.

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

Mikko <mikko.levanto@iki.fi> writes:

> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>
>> Mikko <mikko.levanto@iki.fi> writes:
>>
>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>
>>>> // Linz Turing machine H --- M applied to w
>>>> // --- Does M halts 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
>>> What does H applied to <H> mean? H requires two argumlents.
>>> Do you mean that the unspecified second argument is the empty tape?
>>> Linz always specifies both arguments of H.
>> Turing machines don't have "arguments" -- there is just a tape.
>> Personally, I would prefer a bit more rigour with an explicit notation
>> for the encoding of a pair[1], but Linz is outlining this proof only
>> because is has some historical interest.
>
> When discussing a Turing machine it may be practical to call the
> initial tape content a sequence of arguments if the problem
> specification specifies the input as a combination of separately
> defined parts.

Yes, but that won't help here because you are asking what "H applied to
<H>" might mean. All TM's only require a string, even though in some
cases it's convenient to pretend that there is a sequence of
"arguments".

>> In fact there's nothing wrong with the second to last comment.
>
> You mean "H applied to <H>" instead of "H applied to <H> <H>"?

Yes. You asked "What does H applied to <H> mean?" and I had tried to
answer that. PO makes lots of silly mistakes but there's nothing wrong
with that condition. The meaning should be clear and it follows from
the condition given for (the non-existent TM) H. It's irrelevant, but
it's not wrong.

Also, his writing the conditions like comments might be misleading you.
PO loves to make things unclear and foggy. Clarity is his enemy.

--
Ben.

On 2/16/2024 1:54 PM, Ben Bacarisse wrote:
> Mikko <mikko.levanto@iki.fi> writes:
>
>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>
>>> Mikko <mikko.levanto@iki.fi> writes:
>>>
>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>
>>>>> // Linz Turing machine H --- M applied to w
>>>>> // --- Does M halts 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
>>>> What does H applied to <H> mean? H requires two argumlents.
>>>> Do you mean that the unspecified second argument is the empty tape?
>>>> Linz always specifies both arguments of H.
>>> Turing machines don't have "arguments" -- there is just a tape.
>>> Personally, I would prefer a bit more rigour with an explicit notation
>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>> because is has some historical interest.
>>
>> When discussing a Turing machine it may be practical to call the
>> initial tape content a sequence of arguments if the problem
>> specification specifies the input as a combination of separately
>> defined parts.
>
> Yes, but that won't help here because you are asking what "H applied to
> <H>" might mean. All TM's only require a string, even though in some
> cases it's convenient to pretend that there is a sequence of
> "arguments".
>
>>> In fact there's nothing wrong with the second to last comment.
>>
>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>
> Yes. You asked "What does H applied to <H> mean?" and I had tried to
> answer that. PO makes lots of silly mistakes but there's nothing wrong
> with that condition. The meaning should be clear and it follows from
> the condition given for (the non-existent TM) H. It's irrelevant, but
> it's not wrong.
>
> Also, his writing the conditions like comments might be misleading you.
> PO loves to make things unclear and foggy. Clarity is his enemy.
>

It is clear now that at least two PhD computer science professors
perfectly agree with my 2004 claim that the only reason the halting
problem cannot be solved is that there is something wrong with it.

[3] Bill Stoddart. *The Halting Paradox*
20 December 2017
https://arxiv.org/abs/1906.05340
arXiv:1906.05340 [cs.LO]

[4] E C R Hehner. *Problems with the Halting Problem*, COMPUTING2011
Symposium on 75 years of Turing Machine and Lambda-Calculus, Karlsruhe
Germany, invited, 2011 October 20-21; Advances in Computer Science and
Engineering v.10 n.1 p.31-60, 2013
https://www.cs.toronto.edu/~hehner/PHP.pdf

[5] E C R Hehner. *Objective and Subjective Specifications*, 6 pages,
2017 July 10, WST Workshop on Termination, Oxford, 2018 July 18
https://www.cs.toronto.edu/~hehner/OSS.pdf

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

--
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/16/24 3:13 PM, olcott wrote:
> On 2/16/2024 1:54 PM, Ben Bacarisse wrote:
>> Mikko <mikko.levanto@iki.fi> writes:
>>
>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>
>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>
>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>
>>>>>> // Linz Turing machine H --- M applied to w
>>>>>> // --- Does M halts 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
>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>> Linz always specifies both arguments of H.
>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>> Personally, I would prefer a bit more rigour with an explicit notation
>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>> because is has some historical interest.
>>>
>>> When discussing a Turing machine it may be practical to call the
>>> initial tape content a sequence of arguments if the problem
>>> specification specifies the input as a combination of separately
>>> defined parts.
>>
>> Yes, but that won't help here because you are asking what "H applied to
>> <H>" might mean.  All TM's only require a string, even though in some
>> cases it's convenient to pretend that there is a sequence of
>> "arguments".
>>
>>>> In fact there's nothing wrong with the second to last comment.
>>>
>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>
>> Yes.  You asked "What does H applied to <H> mean?" and I had tried to
>> answer that.  PO makes lots of silly mistakes but there's nothing wrong
>> with that condition.  The meaning should be clear and it follows from
>> the condition given for (the non-existent TM) H.  It's irrelevant, but
>> it's not wrong.
>>
>> Also, his writing the conditions like comments might be misleading you.
>> PO loves to make things unclear and foggy.  Clarity is his enemy.
>>
>
> It is clear now that at least two PhD computer science professors
> perfectly agree with my 2004 claim that the only reason the halting
> problem cannot be solved is that there is something wrong with it.
>
> [3] Bill Stoddart. *The Halting Paradox*
> 20 December 2017
> https://arxiv.org/abs/1906.05340
> arXiv:1906.05340 [cs.LO]
>
> [4] E C R Hehner. *Problems with the Halting Problem*, COMPUTING2011
> Symposium on 75 years of Turing Machine and Lambda-Calculus, Karlsruhe
> Germany, invited, 2011 October 20-21; Advances in Computer Science and
> Engineering v.10 n.1 p.31-60, 2013
> https://www.cs.toronto.edu/~hehner/PHP.pdf
>
> [5] E C R Hehner. *Objective and Subjective Specifications*, 6 pages,
> 2017 July 10, WST Workshop on Termination, Oxford, 2018 July 18
> https://www.cs.toronto.edu/~hehner/OSS.pdf
>
> *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>
>

And it is perfectly clear that THOUSANDS of otherl better know and
better trained Computer Scientist, ones that have actually studied
Compuation Theory, think that all of you are just wrong because you
don't understand what you are talking about.

On 2/16/24 1:00 PM, olcott wrote:
> On 2/16/2024 11:48 AM, Mikko wrote:
>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>
>>> Mikko <mikko.levanto@iki.fi> writes:
>>>
>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>
>>>>> // Linz Turing machine H --- M applied to w
>>>>> // --- Does M halts 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
>>>>
>>>> What does H applied to <H> mean? H requires two argumlents.
>>>> Do you mean that the unspecified second argument is the empty tape?
>>>> Linz always specifies both arguments of H.
>>>
>>> Turing machines don't have "arguments" -- there is just a tape.
>>> Personally, I would prefer a bit more rigour with an explicit notation
>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>> because is has some historical interest.
>>
>> When discussing a Turing machine it may be practical to call the
>> initial tape content a sequence of arguments if the problem
>> specification specifies the input as a combination of separately
>> defined parts.
>>
>>> In fact there's nothing wrong with the second to last comment.
>>
>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>
>
> It was less confusing when I did the Linz transformations
> in reverse order, prepending the copy input states to Linz H
> thus forming Olcott Ȟ
>
> // Olcott Turing machine  Ȟ --- Ȟ applied to ⟨Ȟ⟩ its own description
> // --- Do you halt on your own Turing Machine Description?

Except that isn't the quesiton that your Ȟ is being asked, it is being
asked if the machine described by its input will halt when given a
description of itself.

IT is only asking about itself if it happens to e given a copy of itself.

> Ȟ.q0 ⟨Ȟ⟩ ⊢* embedded_H ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ĥ.qy     // Ȟ applied to ⟨Ȟ⟩ halts
> Ȟ.q0 ⟨Ȟ⟩ ⊢* embedded_H ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ĥ.qn    // Ȟ applied to ⟨Ȟ⟩ does not halt
> Ȟ applied to ⟨Ȟ⟩ simply correctly transitions to Ĥ.qy
>
> Linz Turing machine Ĥ applied to ⟨Ĥ⟩ is the self-contradictory form of
> Olcott Turing machine Ȟ applied to ⟨Ȟ⟩

Which, like in Linz proof, shows that no correct H can exist.

Not that the Halting Question is incorrect (except when it is being
asked about a machine that doesn't exist)

>
> // Linz Turing machine Ĥ --- Ĥ applied to ⟨Ĥ⟩ its own description
> // --- Do you halt on your own Turing Machine Description?
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn     // Ĥ applied to ⟨Ĥ⟩ does not
> halt
> Ĥ applied to ⟨Ĥ⟩ cannot correctly transition to  Ĥ.qy or Ĥ.qn
> because Ĥ applied to ⟨Ĥ⟩ is self contradictory.
>

Nope. Ĥ is H contradictory, not "self".

For any actually existing H, that might be hoped to be a Halt Decider,
there is a correct answer for the input, but H just gets it wrong, so
isn't actually a Halt Decider.

On 2/16/24 1:32 PM, olcott wrote:
> On 2/16/2024 12:21 PM, Mikko wrote:
>> On 2024-02-16 18:00:52 +0000, olcott said:
>>
>>> On 2/16/2024 11:48 AM, Mikko wrote:
>>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>>
>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>
>>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>>
>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>> // --- Does M halts 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
>>>>>>
>>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>>> Linz always specifies both arguments of H.
>>>>>
>>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>>> Personally, I would prefer a bit more rigour with an explicit notation
>>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>>> because is has some historical interest.
>>>>
>>>> When discussing a Turing machine it may be practical to call the
>>>> initial tape content a sequence of arguments if the problem
>>>> specification specifies the input as a combination of separately
>>>> defined parts.
>>>>
>>>>> In fact there's nothing wrong with the second to last comment.
>>>>
>>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>
>>> It was less confusing when I did the Linz transformations
>>> in reverse order, prepending the copy input states to Linz H
>>> thus forming Olcott Ȟ
>>
>> The symbol Ȟ looks too similar to Ĥ and can therefore be confusing.
>> You should use something clearer, e.g., H⁺. In any case, as it is
>> not defined by Linz, you should define it every time you use it.
>>
>
> I am merely making the Linz transformations to the Linz H in
> reverse order so that I can apply the Linz H to its own machine
> description <H> with clean syntax.
>

And if we call that machine H* to make it clearer in symbology.

H* (M) being a machine that duplicates its input and then uses its copy
of H.

We KNOW that H (M) (M) Must halt if H is truely a Halt Decider, since
all Halt Deciders must Halt, thus

H* (H*) which will just use H (H*) (H*) must halt, thus the correct
answer to H (H*) (H*) must be that it will halt.

So H* (H*) must end up in Qy, if H is a correct Halt Decider.

There is nothing problimatic about that.

It is only when you apply the second operation, to make the H^ that Linz
ended with that adds the infinite loop to Qy, that we run into the problem.

H^ no longer has the meaning of being a "Decider", since we KNOW that
for some inputs H^ will not halt, it is only a machine to test our H or
H* deciders on. (and as not being a decider, it can't be
"self-contradictory, as it doesn't assert anything itself).

What we can show now, is that NO H, or H* can give the right answer when
asked about H^ (H^).

This doesn't mean there isn't an answer, as for every existing claimant
to being a Halt Decider that actually exists, H^ (H^) will have a
definite behavior and thus the is a correct answer, just not the one
that the particular claimant returned, thus the claimant is wrong.

The "Liar's Paradox" only come about when you presume (incorrectly) that
a H that always gives the right answer exists, and it is that INCORRECT
presumption that is proved to be wrong by the paradox.

You don't seem to understand that part of logic. You can't just assume
that something exists, and if that assumption leads to a paradox, you
have just proven yourself wrong.

On 2/16/2024 2:39 PM, Richard Damon wrote:
> On 2/16/24 3:13 PM, olcott wrote:
>> On 2/16/2024 1:54 PM, Ben Bacarisse wrote:
>>> Mikko <mikko.levanto@iki.fi> writes:
>>>
>>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>>
>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>
>>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>>
>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>> // --- Does M halts 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
>>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>>> Linz always specifies both arguments of H.
>>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>>> Personally, I would prefer a bit more rigour with an explicit notation
>>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>>> because is has some historical interest.
>>>>
>>>> When discussing a Turing machine it may be practical to call the
>>>> initial tape content a sequence of arguments if the problem
>>>> specification specifies the input as a combination of separately
>>>> defined parts.
>>>
>>> Yes, but that won't help here because you are asking what "H applied to
>>> <H>" might mean.  All TM's only require a string, even though in some
>>> cases it's convenient to pretend that there is a sequence of
>>> "arguments".
>>>
>>>>> In fact there's nothing wrong with the second to last comment.
>>>>
>>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>
>>> Yes.  You asked "What does H applied to <H> mean?" and I had tried to
>>> answer that.  PO makes lots of silly mistakes but there's nothing wrong
>>> with that condition.  The meaning should be clear and it follows from
>>> the condition given for (the non-existent TM) H.  It's irrelevant, but
>>> it's not wrong.
>>>
>>> Also, his writing the conditions like comments might be misleading you.
>>> PO loves to make things unclear and foggy.  Clarity is his enemy.
>>>
>>
>> It is clear now that at least two PhD computer science professors
>> perfectly agree with my 2004 claim that the only reason the halting
>> problem cannot be solved is that there is something wrong with it.
>>
>> [3] Bill Stoddart. *The Halting Paradox*
>> 20 December 2017
>> https://arxiv.org/abs/1906.05340
>> arXiv:1906.05340 [cs.LO]
>>
>> [4] E C R Hehner. *Problems with the Halting Problem*, COMPUTING2011
>> Symposium on 75 years of Turing Machine and Lambda-Calculus, Karlsruhe
>> Germany, invited, 2011 October 20-21; Advances in Computer Science and
>> Engineering v.10 n.1 p.31-60, 2013
>> https://www.cs.toronto.edu/~hehner/PHP.pdf
>>
>> [5] E C R Hehner. *Objective and Subjective Specifications*, 6 pages,
>> 2017 July 10, WST Workshop on Termination, Oxford, 2018 July 18
>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>
>> *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>
>>
>
> And it is perfectly clear that THOUSANDS of otherl better know and
> better trained Computer Scientist, ones that have actually studied
> Compuation Theory, think that all of you are just wrong because you
> don't understand what you are talking about.

When all of math and logic is too freaking stupid to know to
reject self-contradictory expressions it is their stupidity not ours.

--
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/16/2024 2:40 PM, Richard Damon wrote:
> On 2/16/24 1:00 PM, olcott wrote:
>> On 2/16/2024 11:48 AM, Mikko wrote:
>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>
>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>
>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>
>>>>>> // Linz Turing machine H --- M applied to w
>>>>>> // --- Does M halts 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
>>>>>
>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>> Linz always specifies both arguments of H.
>>>>
>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>> Personally, I would prefer a bit more rigour with an explicit notation
>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>> because is has some historical interest.
>>>
>>> When discussing a Turing machine it may be practical to call the
>>> initial tape content a sequence of arguments if the problem
>>> specification specifies the input as a combination of separately
>>> defined parts.
>>>
>>>> In fact there's nothing wrong with the second to last comment.
>>>
>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>
>>
>> It was less confusing when I did the Linz transformations
>> in reverse order, prepending the copy input states to Linz H
>> thus forming Olcott Ȟ
>>
>> // Olcott Turing machine  Ȟ --- Ȟ applied to ⟨Ȟ⟩ its own description
>> // --- Do you halt on your own Turing Machine Description?
>
> Except that isn't the quesiton that your Ȟ is being asked, it is being
> asked if the machine described by its input will halt when given a
> description of itself.
>
> IT is only asking about itself if it happens to e given a copy of itself.

Yes and what I am talking to you I could say that I am
talking to someone or I could say that I am talking to
Richard Damon.

Ȟ applied to ⟨Ȟ⟩ is asking some machine something about some input.
More precisely Ȟ applied to ⟨Ȟ⟩ is asking Ȟ about the halt status
of its own machine description. You can get less precise than this.
You cannot get more accurate than this.

--
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/16/24 4:20 PM, olcott wrote:
> On 2/16/2024 2:40 PM, Richard Damon wrote:
>> On 2/16/24 1:00 PM, olcott wrote:
>>> On 2/16/2024 11:48 AM, Mikko wrote:
>>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>>
>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>
>>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>>
>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>> // --- Does M halts 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
>>>>>>
>>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>>> Linz always specifies both arguments of H.
>>>>>
>>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>>> Personally, I would prefer a bit more rigour with an explicit notation
>>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>>> because is has some historical interest.
>>>>
>>>> When discussing a Turing machine it may be practical to call the
>>>> initial tape content a sequence of arguments if the problem
>>>> specification specifies the input as a combination of separately
>>>> defined parts.
>>>>
>>>>> In fact there's nothing wrong with the second to last comment.
>>>>
>>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>>
>>>
>>> It was less confusing when I did the Linz transformations
>>> in reverse order, prepending the copy input states to Linz H
>>> thus forming Olcott Ȟ
>>>
>>> // Olcott Turing machine  Ȟ --- Ȟ applied to ⟨Ȟ⟩ its own description
>>> // --- Do you halt on your own Turing Machine Description?
>>
>> Except that isn't the quesiton that your Ȟ is being asked, it is being
>> asked if the machine described by its input will halt when given a
>> description of itself.
>>
>> IT is only asking about itself if it happens to e given a copy of itself.
>
> Yes and what I am talking to you I could say that I am
> talking to someone or I could say that I am talking to
> Richard Damon.
>
> Ȟ applied to ⟨Ȟ⟩ is asking some machine something about some input.
> More precisely Ȟ applied to ⟨Ȟ⟩ is asking Ȟ about the halt status
> of its own machine description. You can get less precise than this.
> You cannot get more accurate than this.
>
>
>

But there is no input define that says "yourself".

Yes, Ȟ applied to (Ȟ) is asking it to act on what turns out to be its
own description, but Ȟ doesn't know that, so it isn't answer the
question that mentions itself, only the question that asks about the
computation described by the input it is given.

A program only answers the question that it was designed for.

H is defined to be a decider, and to be correct, its answer must match
the behavior of the computation its input describes.

Ȟ isn't "defined" to be answering a question, but is designed to
generate behavior, so it is correct if that behavior is what happens.

*H* was defined to answer a question, and the input (Ȟ) (Ȟ) isn't asking
it about "itself" but about a machine that is USING a copy of it.

So, the input isn't *SELF* contradictory to H, as it isn't about H
itself, it is just an input that was carefully constructed, based on the
knowledge of what H does, to make H wrong.

The fact that the computation system allows the creation of such a
program for any decider is one thing that makes some decision problem
uncomputable.

It doesn't make asking the question about a computation halting invalid,
just that it shows we can NEVER make a computation that always gets the
right answer, in other words, that the problem is uncomputable, which
for decision problems, is also called undecidable.

On 2/16/24 4:13 PM, olcott wrote:
> On 2/16/2024 2:39 PM, Richard Damon wrote:
>> On 2/16/24 3:13 PM, olcott wrote:
>>> On 2/16/2024 1:54 PM, Ben Bacarisse wrote:
>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>
>>>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>>>
>>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>>
>>>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>>>
>>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>>> // --- Does M halts 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
>>>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>>>> Linz always specifies both arguments of H.
>>>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>>>> Personally, I would prefer a bit more rigour with an explicit
>>>>>> notation
>>>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>>>> because is has some historical interest.
>>>>>
>>>>> When discussing a Turing machine it may be practical to call the
>>>>> initial tape content a sequence of arguments if the problem
>>>>> specification specifies the input as a combination of separately
>>>>> defined parts.
>>>>
>>>> Yes, but that won't help here because you are asking what "H applied to
>>>> <H>" might mean.  All TM's only require a string, even though in some
>>>> cases it's convenient to pretend that there is a sequence of
>>>> "arguments".
>>>>
>>>>>> In fact there's nothing wrong with the second to last comment.
>>>>>
>>>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>>
>>>> Yes.  You asked "What does H applied to <H> mean?" and I had tried to
>>>> answer that.  PO makes lots of silly mistakes but there's nothing wrong
>>>> with that condition.  The meaning should be clear and it follows from
>>>> the condition given for (the non-existent TM) H.  It's irrelevant, but
>>>> it's not wrong.
>>>>
>>>> Also, his writing the conditions like comments might be misleading you.
>>>> PO loves to make things unclear and foggy.  Clarity is his enemy.
>>>>
>>>
>>> It is clear now that at least two PhD computer science professors
>>> perfectly agree with my 2004 claim that the only reason the halting
>>> problem cannot be solved is that there is something wrong with it.
>>>
>>> [3] Bill Stoddart. *The Halting Paradox*
>>> 20 December 2017
>>> https://arxiv.org/abs/1906.05340
>>> arXiv:1906.05340 [cs.LO]
>>>
>>> [4] E C R Hehner. *Problems with the Halting Problem*, COMPUTING2011
>>> Symposium on 75 years of Turing Machine and Lambda-Calculus,
>>> Karlsruhe Germany, invited, 2011 October 20-21; Advances in Computer
>>> Science and Engineering v.10 n.1 p.31-60, 2013
>>> https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>
>>> [5] E C R Hehner. *Objective and Subjective Specifications*, 6 pages,
>>> 2017 July 10, WST Workshop on Termination, Oxford, 2018 July 18
>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>
>>> *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>
>>>
>>
>> And it is perfectly clear that THOUSANDS of otherl better know and
>> better trained Computer Scientist, ones that have actually studied
>> Compuation Theory, think that all of you are just wrong because you
>> don't understand what you are talking about.
>
> When all of math and logic is too freaking stupid to know to
> reject self-contradictory expressions it is their stupidity not ours.
>

Excpet that it DOES know enough.

You are too stupid to understand that CHANGING question to be
self-contradictory isn't a valid change.

Deciders are NEVER about deciding what "they themselves" do, but about
what the input describes, even if that happens to be a description of
themselves.

Saying the question becomes invalid when changed to be about the decider
deciding on itself isn't valid logic, because the question was ALWAYS
about the input, even if that input is given to another decider, which
isn't the machine described by the input, and if that decider can give
the correct answer, the problem was correct.

On 2/16/2024 4:08 PM, Richard Damon wrote:
> On 2/16/24 4:20 PM, olcott wrote:
>> On 2/16/2024 2:40 PM, Richard Damon wrote:
>>> On 2/16/24 1:00 PM, olcott wrote:
>>>> On 2/16/2024 11:48 AM, Mikko wrote:
>>>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>>>
>>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>>
>>>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>>>
>>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>>> // --- Does M halts 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
>>>>>>>
>>>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>>>> Linz always specifies both arguments of H.
>>>>>>
>>>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>>>> Personally, I would prefer a bit more rigour with an explicit
>>>>>> notation
>>>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>>>> because is has some historical interest.
>>>>>
>>>>> When discussing a Turing machine it may be practical to call the
>>>>> initial tape content a sequence of arguments if the problem
>>>>> specification specifies the input as a combination of separately
>>>>> defined parts.
>>>>>
>>>>>> In fact there's nothing wrong with the second to last comment.
>>>>>
>>>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>>>
>>>>
>>>> It was less confusing when I did the Linz transformations
>>>> in reverse order, prepending the copy input states to Linz H
>>>> thus forming Olcott Ȟ
>>>>
>>>> // Olcott Turing machine  Ȟ --- Ȟ applied to ⟨Ȟ⟩ its own description
>>>> // --- Do you halt on your own Turing Machine Description?
>>>
>>> Except that isn't the quesiton that your Ȟ is being asked, it is
>>> being asked if the machine described by its input will halt when
>>> given a description of itself.
>>>
>>> IT is only asking about itself if it happens to e given a copy of
>>> itself.
>>
>> Yes and what I am talking to you I could say that I am
>> talking to someone or I could say that I am talking to
>> Richard Damon.
>>
>> Ȟ applied to ⟨Ȟ⟩ is asking some machine something about some input.
>> More precisely Ȟ applied to ⟨Ȟ⟩ is asking Ȟ about the halt status
>> of its own machine description. You can get less precise than this.
>> You cannot get more accurate than this.
>>
>>
>>
>
> But there is no input define that says "yourself".
>

There is no theoretical reason why computation cannot
at least equal anything that a human mind can do.

When we continue to think of computations at a much lower
level than machine language this point is lost.

An intelligent enough computation could read the Linz
text for itself and fully comprehend the correctness
of what I say.

> Yes, Ȟ applied to (Ȟ) is asking it to act on what turns out to be its
> own description, but Ȟ doesn't know that,

Yet a computation equaling the best human minds would know that.
It would also be able to explain all of the subtle nuances of the
psychology of indoctrination reasons why so many otherwise
intelligent people just can't seem to understand that the Liar
Paradox is not a truth bearer.

Large Language Models LLM's such as ChatGPT conclusively prove
that machines can exceed their original programming many
quadrillions-fold. ChatGTP-4 learned all kinds of things that
have utterly baffled its original programmers.

> so it isn't answer the
> question that mentions itself, only the question that asks about the
> computation described by the input it is given.
>
> A program only answers the question that it was designed for.
>
> H is defined to be a decider, and to be correct, its answer must match
> the behavior of the computation its input describes.
>
> Ȟ isn't "defined" to be answering a question, but is designed to
> generate behavior, so it is correct if that behavior is what happens.
>
> *H* was defined to answer a question, and the input (Ȟ) (Ȟ) isn't asking
> it about "itself" but about a machine that is USING a copy of it.
>
> So, the input isn't *SELF* contradictory to H, as it isn't about H
> itself, it is just an input that was carefully constructed, based on the
> knowledge of what H does, to make H wrong.
>
> The fact that the computation system allows the creation of such a
> program for any decider is one thing that makes some decision problem
> uncomputable.
>
> It doesn't make asking the question about a computation halting invalid,
> just that it shows we can NEVER make a computation that always gets the
> right answer, in other words, that the problem is uncomputable, which
> for decision problems, is also called undecidable.

--
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/16/2024 4:08 PM, Richard Damon wrote:
> On 2/16/24 4:13 PM, olcott wrote:
>> On 2/16/2024 2:39 PM, Richard Damon wrote:
>>> On 2/16/24 3:13 PM, olcott wrote:
>>>> On 2/16/2024 1:54 PM, Ben Bacarisse wrote:
>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>
>>>>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>>>>
>>>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>>>
>>>>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>>>>
>>>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>>>> // --- Does M halts 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
>>>>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>>>>> Linz always specifies both arguments of H.
>>>>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>>>>> Personally, I would prefer a bit more rigour with an explicit
>>>>>>> notation
>>>>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>>>>> because is has some historical interest.
>>>>>>
>>>>>> When discussing a Turing machine it may be practical to call the
>>>>>> initial tape content a sequence of arguments if the problem
>>>>>> specification specifies the input as a combination of separately
>>>>>> defined parts.
>>>>>
>>>>> Yes, but that won't help here because you are asking what "H
>>>>> applied to
>>>>> <H>" might mean.  All TM's only require a string, even though in some
>>>>> cases it's convenient to pretend that there is a sequence of
>>>>> "arguments".
>>>>>
>>>>>>> In fact there's nothing wrong with the second to last comment.
>>>>>>
>>>>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>>>
>>>>> Yes.  You asked "What does H applied to <H> mean?" and I had tried to
>>>>> answer that.  PO makes lots of silly mistakes but there's nothing
>>>>> wrong
>>>>> with that condition.  The meaning should be clear and it follows from
>>>>> the condition given for (the non-existent TM) H.  It's irrelevant, but
>>>>> it's not wrong.
>>>>>
>>>>> Also, his writing the conditions like comments might be misleading
>>>>> you.
>>>>> PO loves to make things unclear and foggy.  Clarity is his enemy.
>>>>>
>>>>
>>>> It is clear now that at least two PhD computer science professors
>>>> perfectly agree with my 2004 claim that the only reason the halting
>>>> problem cannot be solved is that there is something wrong with it.
>>>>
>>>> [3] Bill Stoddart. *The Halting Paradox*
>>>> 20 December 2017
>>>> https://arxiv.org/abs/1906.05340
>>>> arXiv:1906.05340 [cs.LO]
>>>>
>>>> [4] E C R Hehner. *Problems with the Halting Problem*, COMPUTING2011
>>>> Symposium on 75 years of Turing Machine and Lambda-Calculus,
>>>> Karlsruhe Germany, invited, 2011 October 20-21; Advances in Computer
>>>> Science and Engineering v.10 n.1 p.31-60, 2013
>>>> https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>
>>>> [5] E C R Hehner. *Objective and Subjective Specifications*, 6
>>>> pages, 2017 July 10, WST Workshop on Termination, Oxford, 2018 July 18
>>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>>
>>>> *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>
>>>>
>>>
>>> And it is perfectly clear that THOUSANDS of otherl better know and
>>> better trained Computer Scientist, ones that have actually studied
>>> Compuation Theory, think that all of you are just wrong because you
>>> don't understand what you are talking about.
>>
>> When all of math and logic is too freaking stupid to know to
>> reject self-contradictory expressions it is their stupidity not ours.
>>
>
> Excpet that it DOES know enough.
>
> You are too stupid to understand that CHANGING question to be
> self-contradictory isn't a valid change.

When Ĥ is applied to ⟨Ĥ⟩
*is most specifically asking Ĥ about the behavior of itself*

That you can say this more vaguely isn't even a stupid attempt at rebuttal.

I could claim that I am talking to Richard Damon right now and you
could say: "No you are wrong you are not talking to Richard Damon
you are talking to someone or other".

Can you see how stupid this isomorphic rebuttal is?

--
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/16/24 5:48 PM, olcott wrote:
> On 2/16/2024 4:08 PM, Richard Damon wrote:
>> On 2/16/24 4:20 PM, olcott wrote:
>>> On 2/16/2024 2:40 PM, Richard Damon wrote:
>>>> On 2/16/24 1:00 PM, olcott wrote:
>>>>> On 2/16/2024 11:48 AM, Mikko wrote:
>>>>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>>>>
>>>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>>>
>>>>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>>>>
>>>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>>>> // --- Does M halts 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
>>>>>>>>
>>>>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>>>>> Do you mean that the unspecified second argument is the empty tape?
>>>>>>>> Linz always specifies both arguments of H.
>>>>>>>
>>>>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>>>>> Personally, I would prefer a bit more rigour with an explicit
>>>>>>> notation
>>>>>>> for the encoding of a pair[1], but Linz is outlining this proof only
>>>>>>> because is has some historical interest.
>>>>>>
>>>>>> When discussing a Turing machine it may be practical to call the
>>>>>> initial tape content a sequence of arguments if the problem
>>>>>> specification specifies the input as a combination of separately
>>>>>> defined parts.
>>>>>>
>>>>>>> In fact there's nothing wrong with the second to last comment.
>>>>>>
>>>>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>>>>
>>>>>
>>>>> It was less confusing when I did the Linz transformations
>>>>> in reverse order, prepending the copy input states to Linz H
>>>>> thus forming Olcott Ȟ
>>>>>
>>>>> // Olcott Turing machine  Ȟ --- Ȟ applied to ⟨Ȟ⟩ its own description
>>>>> // --- Do you halt on your own Turing Machine Description?
>>>>
>>>> Except that isn't the quesiton that your Ȟ is being asked, it is
>>>> being asked if the machine described by its input will halt when
>>>> given a description of itself.
>>>>
>>>> IT is only asking about itself if it happens to e given a copy of
>>>> itself.
>>>
>>> Yes and what I am talking to you I could say that I am
>>> talking to someone or I could say that I am talking to
>>> Richard Damon.
>>>
>>> Ȟ applied to ⟨Ȟ⟩ is asking some machine something about some input.
>>> More precisely Ȟ applied to ⟨Ȟ⟩ is asking Ȟ about the halt status
>>> of its own machine description. You can get less precise than this.
>>> You cannot get more accurate than this.
>>>
>>>
>>>
>>
>> But there is no input define that says "yourself".
>>
>
> There is no theoretical reason why computation cannot
> at least equal anything that a human mind can do.

Why do you say that?

Do you think the Human mind is a deterministic computatation engine that
only used the defined input?

>
> When we continue to think of computations at a much lower
> level than machine language this point is lost.

So, you don't understand what the word "Computation" means in this context..

Seems par for the course.

>
> An intelligent enough computation could read the Linz
> text for itself and fully comprehend the correctness
> of what I say.
>

You are just showing you don't understand the meaning of the word
"Computation" as used in Compuation Theory.

>> Yes, Ȟ applied to (Ȟ) is asking it to act on what turns out to be its
>> own description, but Ȟ doesn't know that,
>
> Yet a computation equaling the best human minds would know that.
> It would also be able to explain all of the subtle nuances of the
> psychology of indoctrination reasons why so many otherwise
> intelligent people just can't seem to understand that the Liar
> Paradox is not a truth bearer.

You are just showing you don't understand what the word "Compuation" means.

>
> Large Language Models LLM's such as ChatGPT conclusively prove
> that machines can exceed their original programming many
> quadrillions-fold. ChatGTP-4 learned all kinds of things that
> have utterly baffled its original programmers.

Nope, you are just showing you don't understand the meaning of the word
"Computation".

>
>> so it isn't answer the question that mentions itself, only the
>> question that asks about the computation described by the input it is
>> given.
>>
>> A program only answers the question that it was designed for.
>>
>> H is defined to be a decider, and to be correct, its answer must match
>> the behavior of the computation its input describes.
>>
>> Ȟ isn't "defined" to be answering a question, but is designed to
>> generate behavior, so it is correct if that behavior is what happens.
>>
>> *H* was defined to answer a question, and the input (Ȟ) (Ȟ) isn't
>> asking it about "itself" but about a machine that is USING a copy of it.
>>
>> So, the input isn't *SELF* contradictory to H, as it isn't about H
>> itself, it is just an input that was carefully constructed, based on
>> the knowledge of what H does, to make H wrong.
>>
>> The fact that the computation system allows the creation of such a
>> program for any decider is one thing that makes some decision problem
>> uncomputable.
>>
>> It doesn't make asking the question about a computation halting
>> invalid, just that it shows we can NEVER make a computation that
>> always gets the right answer, in other words, that the problem is
>> uncomputable, which for decision problems, is also called undecidable.
>

On 2/16/2024 4:56 PM, Richard Damon wrote:
> On 2/16/24 5:48 PM, olcott wrote:
>> On 2/16/2024 4:08 PM, Richard Damon wrote:
>>> On 2/16/24 4:20 PM, olcott wrote:
>>>> On 2/16/2024 2:40 PM, Richard Damon wrote:
>>>>> On 2/16/24 1:00 PM, olcott wrote:
>>>>>> On 2/16/2024 11:48 AM, Mikko wrote:
>>>>>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>>>>>
>>>>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>>>>
>>>>>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>>>>> // --- Does M halts 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
>>>>>>>>>
>>>>>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>>>>>> Do you mean that the unspecified second argument is the empty
>>>>>>>>> tape?
>>>>>>>>> Linz always specifies both arguments of H.
>>>>>>>>
>>>>>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>>>>>> Personally, I would prefer a bit more rigour with an explicit
>>>>>>>> notation
>>>>>>>> for the encoding of a pair[1], but Linz is outlining this proof
>>>>>>>> only
>>>>>>>> because is has some historical interest.
>>>>>>>
>>>>>>> When discussing a Turing machine it may be practical to call the
>>>>>>> initial tape content a sequence of arguments if the problem
>>>>>>> specification specifies the input as a combination of separately
>>>>>>> defined parts.
>>>>>>>
>>>>>>>> In fact there's nothing wrong with the second to last comment.
>>>>>>>
>>>>>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>>>>>
>>>>>>
>>>>>> It was less confusing when I did the Linz transformations
>>>>>> in reverse order, prepending the copy input states to Linz H
>>>>>> thus forming Olcott Ȟ
>>>>>>
>>>>>> // Olcott Turing machine  Ȟ --- Ȟ applied to ⟨Ȟ⟩ its own description
>>>>>> // --- Do you halt on your own Turing Machine Description?
>>>>>
>>>>> Except that isn't the quesiton that your Ȟ is being asked, it is
>>>>> being asked if the machine described by its input will halt when
>>>>> given a description of itself.
>>>>>
>>>>> IT is only asking about itself if it happens to e given a copy of
>>>>> itself.
>>>>
>>>> Yes and what I am talking to you I could say that I am
>>>> talking to someone or I could say that I am talking to
>>>> Richard Damon.
>>>>
>>>> Ȟ applied to ⟨Ȟ⟩ is asking some machine something about some input.
>>>> More precisely Ȟ applied to ⟨Ȟ⟩ is asking Ȟ about the halt status
>>>> of its own machine description. You can get less precise than this.
>>>> You cannot get more accurate than this.
>>>>
>>>>
>>>>
>>>
>>> But there is no input define that says "yourself".
>>>
>>
>> There is no theoretical reason why computation cannot
>> at least equal anything that a human mind can do.
>
> Why do you say that?
>
> Do you think the Human mind is a deterministic computatation engine that
> only used the defined input?
>
>>
>> When we continue to think of computations at a much lower
>> level than machine language this point is lost.
>
> So, you don't understand what the word "Computation" means in this
> context..
>
> Seems par for the course.
>
>>
>> An intelligent enough computation could read the Linz
>> text for itself and fully comprehend the correctness
>> of what I say.
>>
>
> You are just showing you don't understand the meaning of the word
> "Computation" as used in Compuation Theory.
>
>
>>> Yes, Ȟ applied to (Ȟ) is asking it to act on what turns out to be its
>>> own description, but Ȟ doesn't know that,
>>
>> Yet a computation equaling the best human minds would know that.
>> It would also be able to explain all of the subtle nuances of the
>> psychology of indoctrination reasons why so many otherwise
>> intelligent people just can't seem to understand that the Liar
>> Paradox is not a truth bearer.
>
> You are just showing you don't understand what the word "Compuation" means.
>
>>
>> Large Language Models LLM's such as ChatGPT conclusively prove
>> that machines can exceed their original programming many
>> quadrillions-fold. ChatGTP-4 learned all kinds of things that
>> have utterly baffled its original programmers.
>
> Nope, you are just showing you don't understand the meaning of the word
> "Computation".
>

LLM's prove that I am right and you are ignorant.

>>
>>> so it isn't answer the question that mentions itself, only the
>>> question that asks about the computation described by the input it is
>>> given.
>>>
>>> A program only answers the question that it was designed for.
>>>
>>> H is defined to be a decider, and to be correct, its answer must
>>> match the behavior of the computation its input describes.
>>>
>>> Ȟ isn't "defined" to be answering a question, but is designed to
>>> generate behavior, so it is correct if that behavior is what happens.
>>>
>>> *H* was defined to answer a question, and the input (Ȟ) (Ȟ) isn't
>>> asking it about "itself" but about a machine that is USING a copy of it.
>>>
>>> So, the input isn't *SELF* contradictory to H, as it isn't about H
>>> itself, it is just an input that was carefully constructed, based on
>>> the knowledge of what H does, to make H wrong.
>>>
>>> The fact that the computation system allows the creation of such a
>>> program for any decider is one thing that makes some decision problem
>>> uncomputable.
>>>
>>> It doesn't make asking the question about a computation halting
>>> invalid, just that it shows we can NEVER make a computation that
>>> always gets the right answer, in other words, that the problem is
>>> uncomputable, which for decision problems, is also called undecidable.
>>
>

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

On 16/02/24 16:20, olcott wrote:
> *H applied to ⟨H⟩ ⟨H⟩ correctly transitions to H.qy*

the transition is incorrect because H(H) doesn't halt

On 2/16/24 5:54 PM, olcott wrote:
> On 2/16/2024 4:08 PM, Richard Damon wrote:
>> On 2/16/24 4:13 PM, olcott wrote:
>>> On 2/16/2024 2:39 PM, Richard Damon wrote:
>>>> On 2/16/24 3:13 PM, olcott wrote:
>>>>> On 2/16/2024 1:54 PM, Ben Bacarisse wrote:
>>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>>
>>>>>>> On 2024-02-16 11:43:15 +0000, Ben Bacarisse said:
>>>>>>>
>>>>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>>>>
>>>>>>>>> On 2024-02-16 06:07:04 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> // Linz Turing machine H --- M applied to w
>>>>>>>>>> // --- Does M halts 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
>>>>>>>>> What does H applied to <H> mean? H requires two argumlents.
>>>>>>>>> Do you mean that the unspecified second argument is the empty
>>>>>>>>> tape?
>>>>>>>>> Linz always specifies both arguments of H.
>>>>>>>> Turing machines don't have "arguments" -- there is just a tape.
>>>>>>>> Personally, I would prefer a bit more rigour with an explicit
>>>>>>>> notation
>>>>>>>> for the encoding of a pair[1], but Linz is outlining this proof
>>>>>>>> only
>>>>>>>> because is has some historical interest.
>>>>>>>
>>>>>>> When discussing a Turing machine it may be practical to call the
>>>>>>> initial tape content a sequence of arguments if the problem
>>>>>>> specification specifies the input as a combination of separately
>>>>>>> defined parts.
>>>>>>
>>>>>> Yes, but that won't help here because you are asking what "H
>>>>>> applied to
>>>>>> <H>" might mean.  All TM's only require a string, even though in some
>>>>>> cases it's convenient to pretend that there is a sequence of
>>>>>> "arguments".
>>>>>>
>>>>>>>> In fact there's nothing wrong with the second to last comment.
>>>>>>>
>>>>>>> You mean "H applied to <H>" instead of "H applied to <H> <H>"?
>>>>>>
>>>>>> Yes.  You asked "What does H applied to <H> mean?" and I had tried to
>>>>>> answer that.  PO makes lots of silly mistakes but there's nothing
>>>>>> wrong
>>>>>> with that condition.  The meaning should be clear and it follows from
>>>>>> the condition given for (the non-existent TM) H.  It's irrelevant,
>>>>>> but
>>>>>> it's not wrong.
>>>>>>
>>>>>> Also, his writing the conditions like comments might be misleading
>>>>>> you.
>>>>>> PO loves to make things unclear and foggy.  Clarity is his enemy.
>>>>>>
>>>>>
>>>>> It is clear now that at least two PhD computer science professors
>>>>> perfectly agree with my 2004 claim that the only reason the halting
>>>>> problem cannot be solved is that there is something wrong with it.
>>>>>
>>>>> [3] Bill Stoddart. *The Halting Paradox*
>>>>> 20 December 2017
>>>>> https://arxiv.org/abs/1906.05340
>>>>> arXiv:1906.05340 [cs.LO]
>>>>>
>>>>> [4] E C R Hehner. *Problems with the Halting Problem*,
>>>>> COMPUTING2011 Symposium on 75 years of Turing Machine and
>>>>> Lambda-Calculus, Karlsruhe Germany, invited, 2011 October 20-21;
>>>>> Advances in Computer Science and Engineering v.10 n.1 p.31-60, 2013
>>>>> https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>
>>>>> [5] E C R Hehner. *Objective and Subjective Specifications*, 6
>>>>> pages, 2017 July 10, WST Workshop on Termination, Oxford, 2018 July 18
>>>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>>>
>>>>> *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>
>>>>>
>>>>
>>>> And it is perfectly clear that THOUSANDS of otherl better know and
>>>> better trained Computer Scientist, ones that have actually studied
>>>> Compuation Theory, think that all of you are just wrong because you
>>>> don't understand what you are talking about.
>>>
>>> When all of math and logic is too freaking stupid to know to
>>> reject self-contradictory expressions it is their stupidity not ours.
>>>
>>
>> Excpet that it DOES know enough.
>>
>> You are too stupid to understand that CHANGING question to be
>> self-contradictory isn't a valid change.
>
> When Ĥ is applied to ⟨Ĥ⟩
> *is most specifically asking Ĥ about the behavior of itself*

No, because the string (Ĥ) doesn't mean "itself" but Ĥ.

>
> That you can say this more vaguely isn't even a stupid attempt at rebuttal.

That you keep repeating your errors doesn't make the claim right.

>
> I could claim that I am talking to Richard Damon right now and you
> could say: "No you are wrong you are not talking to Richard Damon
> you are talking to someone or other".
>
> Can you see how stupid this isomorphic rebuttal is?
>

No, you are sending messages to THE WORLD, and addressing Richard Damon.

On 2/16/24 6:02 PM, olcott wrote:
> On 2/16/2024 4:56 PM, Richard Damon wrote:
>> On 2/16/24 5:48 PM, olcott wrote:

>>>
>>> Large Language Models LLM's such as ChatGPT conclusively prove
>>> that machines can exceed their original programming many
>>> quadrillions-fold. ChatGTP-4 learned all kinds of things that
>>> have utterly baffled its original programmers.
>>
>> Nope, you are just showing you don't understand the meaning of the
>> word "Computation".
>>
>
> LLM's prove that I am right and you are ignorant.
>

Nope.

You don't understand how LLM's work, and how what they are compare to
"computations" as defined by Computation Theory.

Note, many LLM programs don't fit in the "Computation" model of
programming, as they don't take a simple "input" and generate a simple
"output".

Your problem is you STILL don't understand what a "Computation" is.