On 16/02/24 23:48, olcott wrote:
>> 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.

That is not true. The best human minds are unable to decode some DRM
schemes that hide program code.

On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:

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

What follows the words "applied to" must specify an input to the
Turing machine identified before those words. Linz does not say
what H is expected to do if the input is not a pair of descritions,
a Turing machine and a tape content. Therefore, whoever says
"H applied to <H>" must tell what that means, in particular,
whether H may answer something else that "yes" or "not".

--
Mikko

On 2/17/2024 4:08 AM, Mikko wrote:
> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>
>> 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".
>
> What follows the words "applied to" must specify an input to the
> Turing machine identified before those words. Linz does not say
> what H is expected to do if the input is not a pair of descritions,
> a Turing machine and a tape content. Therefore, whoever says
> "H applied to <H>" must tell what that means, in particular,
> whether H may answer something else that "yes" or "not".
>

Maybe you should read Linz
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

Linz uses Wm as the TM description of M

// Verbatim Linz Turing machine H --- M applied to w
// --- Does M halt on w?
H.q0 Wm w ⊢* H.qy // M applied to w halts
H.q0 Wm w ⊢* H.qn // M applied to w 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 2/17/24 9:59 AM, olcott wrote:
> On 2/17/2024 4:08 AM, Mikko wrote:
>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>
>>> 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".
>>
>> What follows the words "applied to" must specify an input to the
>> Turing machine identified before those words. Linz does not say
>> what H is expected to do if the input is not a pair of descritions,
>> a Turing machine and a tape content. Therefore, whoever says
>> "H applied to <H>" must tell what that means, in particular,
>> whether H may answer something else that "yes" or "not".
>>
>
> Maybe you should read Linz
> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>
> Linz uses Wm as the TM description of M
>
> // Verbatim Linz Turing machine H --- M applied to w
> // --- Does M halt on w?
> H.q0 Wm w ⊢* H.qy // M applied to w halts
> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>
>

Your missing the point (likely because you don't understand what you are
saying).

H, as defined, takes an input string that is two pieces concatonated
together.

Thus H applied to <H> isn't a proper input for H, unless you are
implicitly meaning H applied to <H> <null> where <null> is the empty
string, and then that would be asking H about H applied to <null> <null>
and what it means to ask H about a machine described by no description.

On 17/02/24 16:49, Richard Damon wrote:
> On 2/17/24 9:59 AM, olcott wrote:
>> On 2/17/2024 4:08 AM, Mikko wrote:
>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>
>>>> 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".
>>>
>>> What follows the words "applied to" must specify an input to the
>>> Turing machine identified before those words. Linz does not say
>>> what H is expected to do if the input is not a pair of descritions,
>>> a Turing machine and a tape content. Therefore, whoever says
>>> "H applied to <H>" must tell what that means, in particular,
>>> whether H may answer something else that "yes" or "not".
>>>
>>
>> Maybe you should read Linz
>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>
>> Linz uses Wm as the TM description of M
>>
>> // Verbatim Linz Turing machine H --- M applied to w
>> // --- Does M halt on w?
>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>>
>>
>
> Your missing the point (likely because you don't understand what you are
> saying).
>
> H, as defined, takes an input string that is two pieces concatonated
> together.
>
> Thus H applied to <H> isn't a proper input for H, unless you are
> implicitly meaning H applied to <H> <null> where <null> is the empty
> string, and then that would be asking H about H applied to <null> <null>
> and what it means to ask H about a machine described by no description.

We all know that it should be H applied to <H> <H> because we know how
the proof is supposed to go. Olcott should know that too, and he should
know that you know that, and he should call you out for unnecessary
pedantry like I am. But the fact he is not doing that does indicate that
perhaps he doesn't know.

On 2/17/2024 4:39 PM, immibis wrote:
> On 17/02/24 16:49, Richard Damon wrote:
>> On 2/17/24 9:59 AM, olcott wrote:
>>> On 2/17/2024 4:08 AM, Mikko wrote:
>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>
>>>>> 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".
>>>>
>>>> What follows the words "applied to" must specify an input to the
>>>> Turing machine identified before those words. Linz does not say
>>>> what H is expected to do if the input is not a pair of descritions,
>>>> a Turing machine and a tape content. Therefore, whoever says
>>>> "H applied to <H>" must tell what that means, in particular,
>>>> whether H may answer something else that "yes" or "not".
>>>>
>>>
>>> Maybe you should read Linz
>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>
>>> Linz uses Wm as the TM description of M
>>>
>>> // Verbatim Linz Turing machine H --- M applied to w
>>> // --- Does M halt on w?
>>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>>>
>>>
>>
>> Your missing the point (likely because you don't understand what you
>> are saying).
>>
>> H, as defined, takes an input string that is two pieces concatonated
>> together.
>>
>> Thus H applied to <H> isn't a proper input for H, unless you are
>> implicitly meaning H applied to <H> <null> where <null> is the empty
>> string, and then that would be asking H about H applied to <null>
>> <null> and what it means to ask H about a machine described by no
>> description.
>
> We all know that it should be H applied to <H> <H> because we know how
> the proof is supposed to go. Olcott should know that too, and he should
> know that you know that, and he should call you out for unnecessary
> pedantry like I am. But the fact he is not doing that does indicate that
> perhaps he doesn't know.

I made the mistake of giving H one param instead of two
when I was converting it to report 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 2024-02-17 14:59:34 +0000, olcott said:

> On 2/17/2024 4:08 AM, Mikko wrote:
>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>
>>> 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".
>>
>> What follows the words "applied to" must specify an input to the
>> Turing machine identified before those words. Linz does not say
>> what H is expected to do if the input is not a pair of descritions,
>> a Turing machine and a tape content. Therefore, whoever says
>> "H applied to <H>" must tell what that means, in particular,
>> whether H may answer something else that "yes" or "not".
>>
>
> Maybe you should read Linz
> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>
> Linz uses Wm as the TM description of M
>
> // Verbatim Linz Turing machine H --- M applied to w
> // --- Does M halt on w?
> H.q0 Wm w ⊢* H.qy // M applied to w halts
> H.q0 Wm w ⊢* H.qn // M applied to w does not halt

A particular caseof this is

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

which you said above. However, Linz does not specify whether
H applied to <H> should halt or not, as the input is not in
the domain of H, so nothing can be inferred from this case,
which therefore is uninteresting.

--
Mikko

On 2/18/2024 4:46 AM, Mikko wrote:
> On 2024-02-17 14:59:34 +0000, olcott said:
>
>> On 2/17/2024 4:08 AM, Mikko wrote:
>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>
>>>> 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".
>>>
>>> What follows the words "applied to" must specify an input to the
>>> Turing machine identified before those words. Linz does not say
>>> what H is expected to do if the input is not a pair of descritions,
>>> a Turing machine and a tape content. Therefore, whoever says
>>> "H applied to <H>" must tell what that means, in particular,
>>> whether H may answer something else that "yes" or "not".
>>>
>>
>> Maybe you should read Linz
>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>
>> Linz uses Wm as the TM description of M
>>
>> // Verbatim Linz Turing machine H --- M applied to w
>> // --- Does M halt on w?
>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>
> A particular caseof this is
>
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>
> which you said above. However, Linz does not specify whether
> H applied to <H> should halt or not, as the input is not in
> the domain of H, so nothing can be inferred from this case,
> which therefore is uninteresting.
>

"Turing machine H will halt with either a yes or no answer.
We achieve this by asking that H halt in one of two
corresponding final states, say, qy or qn."
https://liarparadox.org/Peter_Linz_HP(Pages_318-319).pdf

When we append an infinite loop to the qy then H is required
to reject its input as semantically invalid in the same way
that a natural language truth predicate must reject this:
True(English, "this sentence is not true").

A project such as the Cyc Project converts the English
to its CycL language and then processes it.

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

On 2/18/2024 11:22 AM, Mikko wrote:
> On 2024-02-18 15:27:38 +0000, olcott said:
>
>> On 2/18/2024 4:46 AM, Mikko wrote:
>>> On 2024-02-17 14:59:34 +0000, olcott said:
>>>
>>>> On 2/17/2024 4:08 AM, Mikko wrote:
>>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>>
>>>>>> 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".
>>>>>
>>>>> What follows the words "applied to" must specify an input to the
>>>>> Turing machine identified before those words. Linz does not say
>>>>> what H is expected to do if the input is not a pair of descritions,
>>>>> a Turing machine and a tape content. Therefore, whoever says
>>>>> "H applied to <H>" must tell what that means, in particular,
>>>>> whether H may answer something else that "yes" or "not".
>>>>>
>>>>
>>>> Maybe you should read Linz
>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>
>>>> Linz uses Wm as the TM description of M
>>>>
>>>> // Verbatim Linz Turing machine H --- M applied to w
>>>> // --- Does M halt on w?
>>>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>>>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>>>
>>> A particular caseof this is
>>>
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>
>>> which you said above. However, Linz does not specify whether
>>> H applied to <H> should halt or not, as the input is not in
>>> the domain of H, so nothing can be inferred from this case,
>>> which therefore is uninteresting.
>>>
>>
>> "Turing machine H will halt with either a yes or no answer.
>> We achieve this by asking that H halt in one of two
>> corresponding final states, say, qy or qn."
>> https://liarparadox.org/Peter_Linz_HP(Pages_318-319).pdf
>
> Your quote is wrong. A partial sentence should not be quoted
> without a good reason and when there q good reason to omit
> a part of a sentence the omission should be clearly indicated
> (usually with trhree dots).
>

There cannot possibly be any context that would not be
self-contradictory thus context is irrelevant.

--
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-18 17:39:17 +0000, olcott said:

> On 2/18/2024 11:22 AM, Mikko wrote:
>> On 2024-02-18 15:27:38 +0000, olcott said:
>>
>>> On 2/18/2024 4:46 AM, Mikko wrote:
>>>> On 2024-02-17 14:59:34 +0000, olcott said:
>>>>
>>>>> On 2/17/2024 4:08 AM, Mikko wrote:
>>>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>>>
>>>>>>> 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".
>>>>>>
>>>>>> What follows the words "applied to" must specify an input to the
>>>>>> Turing machine identified before those words. Linz does not say
>>>>>> what H is expected to do if the input is not a pair of descritions,
>>>>>> a Turing machine and a tape content. Therefore, whoever says
>>>>>> "H applied to <H>" must tell what that means, in particular,
>>>>>> whether H may answer something else that "yes" or "not".
>>>>>>
>>>>>
>>>>> Maybe you should read Linz
>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>>
>>>>> Linz uses Wm as the TM description of M
>>>>>
>>>>> // Verbatim Linz Turing machine H --- M applied to w
>>>>> // --- Does M halt on w?
>>>>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>>>>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>>>>
>>>> A particular caseof this is
>>>>
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>>
>>>> which you said above. However, Linz does not specify whether
>>>> H applied to <H> should halt or not, as the input is not in
>>>> the domain of H, so nothing can be inferred from this case,
>>>> which therefore is uninteresting.
>>>>
>>>
>>> "Turing machine H will halt with either a yes or no answer.
>>> We achieve this by asking that H halt in one of two
>>> corresponding final states, say, qy or qn."
>>> https://liarparadox.org/Peter_Linz_HP(Pages_318-319).pdf
>>
>> Your quote is wrong. A partial sentence should not be quoted
>> without a good reason and when there q good reason to omit
>> a part of a sentence the omission should be clearly indicated
>> (usually with trhree dots).
>>
>
> There cannot possibly be any context that would not be
> self-contradictory thus context is irrelevant.

Every part of the sentence is essential, otherwise it would not
be included in that sentence.

If a part of a sentence is omitted without an indication of omission
that is usually considered a lie.

--
Mikko

On 2/18/2024 11:55 AM, Mikko wrote:
> On 2024-02-18 17:39:17 +0000, olcott said:
>
>> On 2/18/2024 11:22 AM, Mikko wrote:
>>> On 2024-02-18 15:27:38 +0000, olcott said:
>>>
>>>> On 2/18/2024 4:46 AM, Mikko wrote:
>>>>> On 2024-02-17 14:59:34 +0000, olcott said:
>>>>>
>>>>>> On 2/17/2024 4:08 AM, Mikko wrote:
>>>>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>>>>
>>>>>>>> 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".
>>>>>>>
>>>>>>> What follows the words "applied to" must specify an input to the
>>>>>>> Turing machine identified before those words. Linz does not say
>>>>>>> what H is expected to do if the input is not a pair of descritions,
>>>>>>> a Turing machine and a tape content. Therefore, whoever says
>>>>>>> "H applied to <H>" must tell what that means, in particular,
>>>>>>> whether H may answer something else that "yes" or "not".
>>>>>>>
>>>>>>
>>>>>> Maybe you should read Linz
>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>>>
>>>>>> Linz uses Wm as the TM description of M
>>>>>>
>>>>>> // Verbatim Linz Turing machine H --- M applied to w
>>>>>> // --- Does M halt on w?
>>>>>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>>>>>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>>>>>
>>>>> A particular caseof this is
>>>>>
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>>>
>>>>> which you said above. However, Linz does not specify whether
>>>>> H applied to <H> should halt or not, as the input is not in
>>>>> the domain of H, so nothing can be inferred from this case,
>>>>> which therefore is uninteresting.
>>>>>
>>>>
>>>> "Turing machine H will halt with either a yes or no answer.
>>>> We achieve this by asking that H halt in one of two
>>>> corresponding final states, say, qy or qn."
>>>> https://liarparadox.org/Peter_Linz_HP(Pages_318-319).pdf
>>>
>>> Your quote is wrong. A partial sentence should not be quoted
>>> without a good reason and when there q good reason to omit
>>> a part of a sentence the omission should be clearly indicated
>>> (usually with trhree dots).
>>>
>>
>> There cannot possibly be any context that would not be
>> self-contradictory thus context is irrelevant.
>
> Every part of the sentence is essential, otherwise it would not
> be included in that sentence.
>
> If a part of a sentence is omitted without an indication of omission
> that is usually considered a lie.
>

It is common knowledge that a halt deciders must
always halt thus your whole issue was always moot.

--
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/18/24 10:27 AM, olcott wrote:
> On 2/18/2024 4:46 AM, Mikko wrote:
>> On 2024-02-17 14:59:34 +0000, olcott said:
>>
>>> On 2/17/2024 4:08 AM, Mikko wrote:
>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>
>>>>> 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".
>>>>
>>>> What follows the words "applied to" must specify an input to the
>>>> Turing machine identified before those words. Linz does not say
>>>> what H is expected to do if the input is not a pair of descritions,
>>>> a Turing machine and a tape content. Therefore, whoever says
>>>> "H applied to <H>" must tell what that means, in particular,
>>>> whether H may answer something else that "yes" or "not".
>>>>
>>>
>>> Maybe you should read Linz
>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>
>>> Linz uses Wm as the TM description of M
>>>
>>> // Verbatim Linz Turing machine H --- M applied to w
>>> // --- Does M halt on w?
>>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>>
>> A particular caseof this is
>>
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>
>> which you said above. However, Linz does not specify whether
>> H applied to <H> should halt or not, as the input is not in
>> the domain of H, so nothing can be inferred from this case,
>> which therefore is uninteresting.
>>
>
> "Turing machine H will halt with either a yes or no answer.
> We achieve this by asking that H halt in one of two
> corresponding final states, say, qy or qn."
> https://liarparadox.org/Peter_Linz_HP(Pages_318-319).pdf
>
> When we append an infinite loop to the qy then H is required
> to reject its input as semantically invalid in the same way
> that a natural language truth predicate must reject this:
> True(English, "this sentence is not true").

And what is "Semantically invalid" about a machine behaving in a defined
way based on prior calculaitons.

That sounds like the DEFINITION of "Semantics" in Computation Theory.

What is Semantically invalid in your description is the assumption that
a Turing Machine H that gets the right answer must exist.

>
> A project such as the Cyc Project converts the English
> to its CycL language and then processes it.
>

On 18/02/24 16:27, olcott wrote:
> On 2/18/2024 4:46 AM, Mikko wrote:
>> On 2024-02-17 14:59:34 +0000, olcott said:
>>
>>> On 2/17/2024 4:08 AM, Mikko wrote:
>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>
>>>>> 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".
>>>>
>>>> What follows the words "applied to" must specify an input to the
>>>> Turing machine identified before those words. Linz does not say
>>>> what H is expected to do if the input is not a pair of descritions,
>>>> a Turing machine and a tape content. Therefore, whoever says
>>>> "H applied to <H>" must tell what that means, in particular,
>>>> whether H may answer something else that "yes" or "not".
>>>>
>>>
>>> Maybe you should read Linz
>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>
>>> Linz uses Wm as the TM description of M
>>>
>>> // Verbatim Linz Turing machine H --- M applied to w
>>> // --- Does M halt on w?
>>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>>
>> A particular caseof this is
>>
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>
>> which you said above. However, Linz does not specify whether
>> H applied to <H> should halt or not, as the input is not in
>> the domain of H, so nothing can be inferred from this case,
>> which therefore is uninteresting.
>>
>
> "Turing machine H will halt with either a yes or no answer.
> We achieve this by asking that H halt in one of two
> corresponding final states, say, qy or qn."
> https://liarparadox.org/Peter_Linz_HP(Pages_318-319).pdf
>
> When we append an infinite loop to the qy then H is required
> to reject its input as semantically invalid in the same way
> that a natural language truth predicate must reject this:
> True(English, "this sentence is not true").
>
> A project such as the Cyc Project converts the English
> to its CycL language and then processes it.
>

We are talking about the Turing machine halting problem, not the CycL
halting problem.

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

> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>
>> 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".
>
> What follows the words "applied to" must specify an input to the
> Turing machine identified before those words. Linz does not say
> what H is expected to do if the input is not a pair of descritions,
> a Turing machine and a tape content. Therefore, whoever says
> "H applied to <H>" must tell what that means,

Linz tells us that "<M> w" is accepted by H (i.e. H transitions to qy)
if M halts on input w. Therefore Linz is telling us that H accepts "<H>
<H>" if H applied to <H> halts. All PO has done is substitute H for M
and <H> for w. That's valid, even in Linz's rather vague notion of the
exact strings involved. M is any TM, so substituting H (were it to
exist) is a reasonable thing to do. And w can be any string, so there
is nothing to stop PO substituting <H> for w.

So there is no doubt about what the phrase means. H will go through
some unknown sequence of transitions when run with <H> on the tape. It
most certainly will or will not halt even though the input is not in the
problem domain.

> in particular,
> whether H may answer something else that "yes" or "not".

That's asking way more than what the phrase means! It's not entirely
clear what you mean be "answer" here, but Linz's TMs always do one three
things for any input: they accept, they reject or they don't halt. I'd
call the first two an "answer", but a TM (and H in particular) does not
give and answer on all inputs.

Linz does not say (and he does not care) what H might do when presented
with <H> on the tape because in his presentation only some strings
(though sadly not an exactly defined set of strings) are in the problem
domain. We /can/ say (because Linz tells us) that H will accept <H> <H>
if H halts on <H> and that H will reject <H> <H> if H does not halt on
<H>, but he does not care which of these is the case because <H> is not
the representation of an instance of the halting problem.

You could have asked PO why he cares what H does when given a string
like <H> that does not represent an HP instance (but he'd have no idea
what you were asking), but there is no doubt what the phrase in question
means. Any TM at all will either halt or not halt when given <H> and
there's nothing special about H in this regard.

--
Ben.

On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
> Mikko <mikko.levanto@iki.fi> writes:
>
>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>
>>> 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".
>>
>> What follows the words "applied to" must specify an input to the
>> Turing machine identified before those words. Linz does not say
>> what H is expected to do if the input is not a pair of descritions,
>> a Turing machine and a tape content. Therefore, whoever says
>> "H applied to <H>" must tell what that means,
>
> Linz tells us that "<M> w" is accepted by H (i.e. H transitions to qy)
> if M halts on input w. Therefore Linz is telling us that H accepts "<H>
> <H>" if H applied to <H> halts. All PO has done is substitute H for M
> and <H> for w. That's valid, even in Linz's rather vague notion of the
> exact strings involved. M is any TM, so substituting H (were it to
> exist) is a reasonable thing to do. And w can be any string, so there
> is nothing to stop PO substituting <H> for w.
>
> So there is no doubt about what the phrase means. H will go through
> some unknown sequence of transitions when run with <H> on the tape. It
> most certainly will or will not halt even though the input is not in the
> problem domain.

*The input <is> in the problem domain*
H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt

The Turing machine description of an element of the infinite
set of Turing machines defined by the Linz template is not
in the domain of a halt decider?

⊢* a finite number of one or more state transitions
Linz: "an arbitrary number of moves"

>> in particular,
>> whether H may answer something else that "yes" or "not".
>
> That's asking way more than what the phrase means! It's not entirely
> clear what you mean be "answer" here, but Linz's TMs always do one three
> things for any input: they accept, they reject or they don't halt. I'd
> call the first two an "answer", but a TM (and H in particular) does not
> give and answer on all inputs.
>
> Linz does not say (and he does not care) what H might do when presented
> with <H> on the tape because in his presentation only some strings
> (though sadly not an exactly defined set of strings) are in the problem
> domain. We /can/ say (because Linz tells us) that H will accept <H> <H>
> if H halts on <H> and that H will reject <H> <H> if H does not halt on
> <H>, but he does not care which of these is the case because <H> is not
> the representation of an instance of the halting problem.
>
> You could have asked PO why he cares what H does when given a string
> like <H> that does not represent an HP instance (but he'd have no idea
> what you were asking),

// *The self-contradictory version of H*
Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn // Ȟ applied to ⟨Ȟ⟩ does not halt

> but there is no doubt what the phrase in question
> means. Any TM at all will either halt or not halt when given <H> and
> there's nothing special about H in this regard.
>

--
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/18/24 7:09 PM, olcott wrote:
> On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
>> Mikko <mikko.levanto@iki.fi> writes:
>>
>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>
>>>> 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".
>>>
>>> What follows the words "applied to" must specify an input to the
>>> Turing machine identified before those words. Linz does not say
>>> what H is expected to do if the input is not a pair of descritions,
>>> a Turing machine and a tape content. Therefore, whoever says
>>> "H applied to <H>" must tell what that means,
>>
>> Linz tells us that "<M> w" is accepted by H (i.e. H transitions to qy)
>> if M halts on input w.  Therefore Linz is telling us that H accepts "<H>
>> <H>" if H applied to <H> halts.  All PO has done is substitute H for M
>> and <H> for w.  That's valid, even in Linz's rather vague notion of the
>> exact strings involved.  M is any TM, so substituting H (were it to
>> exist) is a reasonable thing to do.  And w can be any string, so there
>> is nothing to stop PO substituting <H> for w.
>>
>> So there is no doubt about what the phrase means.  H will go through
>> some unknown sequence of transitions when run with <H> on the tape.  It
>> most certainly will or will not halt even though the input is not in the
>> problem domain.
>
> *The input <is> in the problem domain*
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn  // H applied to ⟨H⟩ does not halt
>
> The Turing machine description of an element of the infinite
> set of Turing machines defined by the Linz template is not
> in the domain of a halt decider?
>

The issue is that H was defined to take as an input a pair of
descriptions, what is it defined to do when the second one is missing?

Is that just an empty tape?

If so, then the Computation being asked about is H applied to nothing

What Turing Machine is decribed by an empty tape?

What is a Halt Decider supposed to do if given an input that doesn't
represent a Turing machine (+ an input tape)?

You seem to have just flown right over the problem being described,
likely because you totally don't understand what a Turing Machine is.

And think that two machines with different behavior can be the "same
machine".

> ⊢* a finite number of one or more state transitions
> Linz: "an arbitrary number of moves"
>
>>> in particular,
>>> whether H may answer something else that "yes" or "not".
>>
>> That's asking way more than what the phrase means!  It's not entirely
>> clear what you mean be "answer" here, but Linz's TMs always do one three
>> things for any input: they accept, they reject or they don't halt.  I'd
>> call the first two an "answer", but a TM (and H in particular) does not
>> give and answer on all inputs.
>>
>> Linz does not say (and he does not care) what H might do when presented
>> with <H> on the tape because in his presentation only some strings
>> (though sadly not an exactly defined set of strings) are in the problem
>> domain.  We /can/ say (because Linz tells us) that H will accept <H> <H>
>> if H halts on <H> and that H will reject <H> <H> if H does not halt on
>> <H>, but he does not care which of these is the case because <H> is not
>> the representation of an instance of the halting problem.
>>
>> You could have asked PO why he cares what H does when given a string
>> like <H> that does not represent an HP instance (but he'd have no idea
>> what you were asking),
>
> // *The self-contradictory version of H*

Not a "Version of H" but a different machine.

You CLEARLY are showing your stupidity here.

> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn   // Ȟ applied to ⟨Ȟ⟩ does not halt
>
>>  but there is no doubt what the phrase in question
>> means.  Any TM at all will either halt or not halt when given <H> and
>> there's nothing special about H in this regard.
>>
>

On 2/18/2024 7:32 PM, Richard Damon wrote:
> On 2/18/24 7:09 PM, olcott wrote:
>> On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
>>> Mikko <mikko.levanto@iki.fi> writes:
>>>
>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>
>>>>> 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".
>>>>
>>>> What follows the words "applied to" must specify an input to the
>>>> Turing machine identified before those words. Linz does not say
>>>> what H is expected to do if the input is not a pair of descritions,
>>>> a Turing machine and a tape content. Therefore, whoever says
>>>> "H applied to <H>" must tell what that means,
>>>
>>> Linz tells us that "<M> w" is accepted by H (i.e. H transitions to qy)
>>> if M halts on input w.  Therefore Linz is telling us that H accepts "<H>
>>> <H>" if H applied to <H> halts.  All PO has done is substitute H for M
>>> and <H> for w.  That's valid, even in Linz's rather vague notion of the
>>> exact strings involved.  M is any TM, so substituting H (were it to
>>> exist) is a reasonable thing to do.  And w can be any string, so there
>>> is nothing to stop PO substituting <H> for w.
>>>
>>> So there is no doubt about what the phrase means.  H will go through
>>> some unknown sequence of transitions when run with <H> on the tape.  It
>>> most certainly will or will not halt even though the input is not in the
>>> problem domain.
>>
>> *The input <is> in the problem domain*
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn  // H applied to ⟨H⟩ does not halt
>>
>> The Turing machine description of an element of the infinite
>> set of Turing machines defined by the Linz template is not
>> in the domain of a halt decider?
>>
>
> The issue is that H was defined to take as an input a pair of
> descriptions,

You are pretending to not know how to count to two?

--
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/18/24 8:34 PM, olcott wrote:
> On 2/18/2024 7:32 PM, Richard Damon wrote:
>> On 2/18/24 7:09 PM, olcott wrote:
>>> On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>
>>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>>
>>>>>> 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".
>>>>>
>>>>> What follows the words "applied to" must specify an input to the
>>>>> Turing machine identified before those words. Linz does not say
>>>>> what H is expected to do if the input is not a pair of descritions,
>>>>> a Turing machine and a tape content. Therefore, whoever says
>>>>> "H applied to <H>" must tell what that means,
>>>>
>>>> Linz tells us that "<M> w" is accepted by H (i.e. H transitions to qy)
>>>> if M halts on input w.  Therefore Linz is telling us that H accepts
>>>> "<H>
>>>> <H>" if H applied to <H> halts.  All PO has done is substitute H for M
>>>> and <H> for w.  That's valid, even in Linz's rather vague notion of the
>>>> exact strings involved.  M is any TM, so substituting H (were it to
>>>> exist) is a reasonable thing to do.  And w can be any string, so there
>>>> is nothing to stop PO substituting <H> for w.
>>>>
>>>> So there is no doubt about what the phrase means.  H will go through
>>>> some unknown sequence of transitions when run with <H> on the tape.  It
>>>> most certainly will or will not halt even though the input is not in
>>>> the
>>>> problem domain.
>>>
>>> *The input <is> in the problem domain*
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn  // H applied to ⟨H⟩ does not halt
>>>
>>> The Turing machine description of an element of the infinite
>>> set of Turing machines defined by the Linz template is not
>>> in the domain of a halt decider?
>>>
>>
>> The issue is that H was defined to take as an input a pair of
>> descriptions,
>
> You are pretending to not know how to count to two?
>

The Computation being run is H (H) (H)

The Question thus being asked is "Does H applied to (H) Halt?"

But H needs to be given two parameters, so that is not a correct question.

Can YOU count to two?

Or are you too stupid to do it the two times needed.

On 19/02/24 01:09, olcott wrote:
> On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
>> Mikko <mikko.levanto@iki.fi> writes:
>>
>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>
>>>> 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".
>>>
>>> What follows the words "applied to" must specify an input to the
>>> Turing machine identified before those words. Linz does not say
>>> what H is expected to do if the input is not a pair of descritions,
>>> a Turing machine and a tape content. Therefore, whoever says
>>> "H applied to <H>" must tell what that means,
>>
>> Linz tells us that "<M> w" is accepted by H (i.e. H transitions to qy)
>> if M halts on input w.  Therefore Linz is telling us that H accepts "<H>
>> <H>" if H applied to <H> halts.  All PO has done is substitute H for M
>> and <H> for w.  That's valid, even in Linz's rather vague notion of the
>> exact strings involved.  M is any TM, so substituting H (were it to
>> exist) is a reasonable thing to do.  And w can be any string, so there
>> is nothing to stop PO substituting <H> for w.
>>
>> So there is no doubt about what the phrase means.  H will go through
>> some unknown sequence of transitions when run with <H> on the tape.  It
>> most certainly will or will not halt even though the input is not in the
>> problem domain.
>
> *The input <is> in the problem domain*
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn  // H applied to ⟨H⟩ does not halt
>
> The Turing machine description of an element of the infinite
> set of Turing machines defined by the Linz template is not
> in the domain of a halt decider?
>
> ⊢* a finite number of one or more state transitions
> Linz: "an arbitrary number of moves"
>
>>> in particular,
>>> whether H may answer something else that "yes" or "not".
>>
>> That's asking way more than what the phrase means!  It's not entirely
>> clear what you mean be "answer" here, but Linz's TMs always do one three
>> things for any input: they accept, they reject or they don't halt.  I'd
>> call the first two an "answer", but a TM (and H in particular) does not
>> give and answer on all inputs.
>>
>> Linz does not say (and he does not care) what H might do when presented
>> with <H> on the tape because in his presentation only some strings
>> (though sadly not an exactly defined set of strings) are in the problem
>> domain.  We /can/ say (because Linz tells us) that H will accept <H> <H>
>> if H halts on <H> and that H will reject <H> <H> if H does not halt on
>> <H>, but he does not care which of these is the case because <H> is not
>> the representation of an instance of the halting problem.
>>
>> You could have asked PO why he cares what H does when given a string
>> like <H> that does not represent an HP instance (but he'd have no idea
>> what you were asking),
>
> // *The self-contradictory version of H*
> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn   // Ȟ applied to ⟨Ȟ⟩ does not halt

You have completely ignored what Ben wrote. Well done.

On 2/18/2024 8:38 PM, immibis wrote:
> On 19/02/24 01:09, olcott wrote:
>> On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
>>> Mikko <mikko.levanto@iki.fi> writes:
>>>
>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>
>>>>> 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".
>>>>
>>>> What follows the words "applied to" must specify an input to the
>>>> Turing machine identified before those words. Linz does not say
>>>> what H is expected to do if the input is not a pair of descritions,
>>>> a Turing machine and a tape content. Therefore, whoever says
>>>> "H applied to <H>" must tell what that means,
>>>
>>> Linz tells us that "<M> w" is accepted by H (i.e. H transitions to qy)
>>> if M halts on input w.  Therefore Linz is telling us that H accepts "<H>
>>> <H>" if H applied to <H> halts.  All PO has done is substitute H for M
>>> and <H> for w.  That's valid, even in Linz's rather vague notion of the
>>> exact strings involved.  M is any TM, so substituting H (were it to
>>> exist) is a reasonable thing to do.  And w can be any string, so there
>>> is nothing to stop PO substituting <H> for w.
>>>
>>> So there is no doubt about what the phrase means.  H will go through
>>> some unknown sequence of transitions when run with <H> on the tape.  It
>>> most certainly will or will not halt even though the input is not in the
>>> problem domain.
>>
>> *The input <is> in the problem domain*
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn  // H applied to ⟨H⟩ does not halt
>>
>> The Turing machine description of an element of the infinite
>> set of Turing machines defined by the Linz template is not
>> in the domain of a halt decider?
>>
>> ⊢* a finite number of one or more state transitions
>> Linz: "an arbitrary number of moves"
>>
>>>> in particular,
>>>> whether H may answer something else that "yes" or "not".
>>>
>>> That's asking way more than what the phrase means!  It's not entirely
>>> clear what you mean be "answer" here, but Linz's TMs always do one three
>>> things for any input: they accept, they reject or they don't halt.  I'd
>>> call the first two an "answer", but a TM (and H in particular) does not
>>> give and answer on all inputs.
>>>
>>> Linz does not say (and he does not care) what H might do when presented
>>> with <H> on the tape because in his presentation only some strings
>>> (though sadly not an exactly defined set of strings) are in the problem
>>> domain.  We /can/ say (because Linz tells us) that H will accept <H> <H>
>>> if H halts on <H> and that H will reject <H> <H> if H does not halt on
>>> <H>, but he does not care which of these is the case because <H> is not
>>> the representation of an instance of the halting problem.
>>>
>>> You could have asked PO why he cares what H does when given a string
>>> like <H> that does not represent an HP instance (but he'd have no idea
>>> what you were asking),
>>
>> // *The self-contradictory version of H*
>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn   // Ȟ applied to ⟨Ȟ⟩ does not halt
>
> You have completely ignored what Ben wrote. Well done.
>

*I appreciate that Ben is here*

He understood that my syntax was correct.
He seemed to make one mistake.

He tried to get away with saying that I don't
understand things so here I prove otherwise
as shown above by:

*H and its self-contradictory*
*version Ȟ prove that I am correct*

--
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-18 17:57:20 +0000, olcott said:

> On 2/18/2024 11:55 AM, Mikko wrote:
>> On 2024-02-18 17:39:17 +0000, olcott said:
>>
>>> On 2/18/2024 11:22 AM, Mikko wrote:
>>>> On 2024-02-18 15:27:38 +0000, olcott said:
>>>>
>>>>> On 2/18/2024 4:46 AM, Mikko wrote:
>>>>>> On 2024-02-17 14:59:34 +0000, olcott said:
>>>>>>
>>>>>>> On 2/17/2024 4:08 AM, Mikko wrote:
>>>>>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>>>>>
>>>>>>>>> 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".
>>>>>>>>
>>>>>>>> What follows the words "applied to" must specify an input to the
>>>>>>>> Turing machine identified before those words. Linz does not say
>>>>>>>> what H is expected to do if the input is not a pair of descritions,
>>>>>>>> a Turing machine and a tape content. Therefore, whoever says
>>>>>>>> "H applied to <H>" must tell what that means, in particular,
>>>>>>>> whether H may answer something else that "yes" or "not".
>>>>>>>>
>>>>>>>
>>>>>>> Maybe you should read Linz
>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>>>>
>>>>>>> Linz uses Wm as the TM description of M
>>>>>>>
>>>>>>> // Verbatim Linz Turing machine H --- M applied to w
>>>>>>> // --- Does M halt on w?
>>>>>>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>>>>>>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>>>>>>
>>>>>> A particular caseof this is
>>>>>>
>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>>>>
>>>>>> which you said above. However, Linz does not specify whether
>>>>>> H applied to <H> should halt or not, as the input is not in
>>>>>> the domain of H, so nothing can be inferred from this case,
>>>>>> which therefore is uninteresting.
>>>>>>
>>>>>
>>>>> "Turing machine H will halt with either a yes or no answer.
>>>>> We achieve this by asking that H halt in one of two
>>>>> corresponding final states, say, qy or qn."
>>>>> https://liarparadox.org/Peter_Linz_HP(Pages_318-319).pdf
>>>>
>>>> Your quote is wrong. A partial sentence should not be quoted
>>>> without a good reason and when there q good reason to omit
>>>> a part of a sentence the omission should be clearly indicated
>>>> (usually with trhree dots).
>>>>
>>>
>>> There cannot possibly be any context that would not be
>>> self-contradictory thus context is irrelevant.
>>
>> Every part of the sentence is essential, otherwise it would not
>> be included in that sentence.
>>
>> If a part of a sentence is omitted without an indication of omission
>> that is usually considered a lie.
>>
>
> It is common knowledge that a halt deciders must
> always halt thus your whole issue was always moot.

As I said, by usual convetions you lied when you quoted a part of a
sentence without an indication that a part of the sentence was not
quoted. Nice to see that you don't disagree.

--
Mikko

immibis <news@immibis.com> writes:

> You have completely ignored what Ben wrote. Well done.

Note that my reply was to a post by Mikko. I don't even see PO posts
anymore.

In an attempt to make a topical thread, I'll start a new one about
Linz's proofs because I think there are a few interesting things to be
said...

--
Ben.

On 2/19/24 12:58 AM, olcott wrote:
> On 2/18/2024 8:38 PM, immibis wrote:
>> On 19/02/24 01:09, olcott wrote:
>>> On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>
>>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>>
>>>>>> 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".
>>>>>
>>>>> What follows the words "applied to" must specify an input to the
>>>>> Turing machine identified before those words. Linz does not say
>>>>> what H is expected to do if the input is not a pair of descritions,
>>>>> a Turing machine and a tape content. Therefore, whoever says
>>>>> "H applied to <H>" must tell what that means,
>>>>
>>>> Linz tells us that "<M> w" is accepted by H (i.e. H transitions to qy)
>>>> if M halts on input w.  Therefore Linz is telling us that H accepts
>>>> "<H>
>>>> <H>" if H applied to <H> halts.  All PO has done is substitute H for M
>>>> and <H> for w.  That's valid, even in Linz's rather vague notion of the
>>>> exact strings involved.  M is any TM, so substituting H (were it to
>>>> exist) is a reasonable thing to do.  And w can be any string, so there
>>>> is nothing to stop PO substituting <H> for w.
>>>>
>>>> So there is no doubt about what the phrase means.  H will go through
>>>> some unknown sequence of transitions when run with <H> on the tape.  It
>>>> most certainly will or will not halt even though the input is not in
>>>> the
>>>> problem domain.
>>>
>>> *The input <is> in the problem domain*
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn  // H applied to ⟨H⟩ does not halt
>>>
>>> The Turing machine description of an element of the infinite
>>> set of Turing machines defined by the Linz template is not
>>> in the domain of a halt decider?
>>>
>>> ⊢* a finite number of one or more state transitions
>>> Linz: "an arbitrary number of moves"
>>>
>>>>> in particular,
>>>>> whether H may answer something else that "yes" or "not".
>>>>
>>>> That's asking way more than what the phrase means!  It's not entirely
>>>> clear what you mean be "answer" here, but Linz's TMs always do one
>>>> three
>>>> things for any input: they accept, they reject or they don't halt.  I'd
>>>> call the first two an "answer", but a TM (and H in particular) does not
>>>> give and answer on all inputs.
>>>>
>>>> Linz does not say (and he does not care) what H might do when presented
>>>> with <H> on the tape because in his presentation only some strings
>>>> (though sadly not an exactly defined set of strings) are in the problem
>>>> domain.  We /can/ say (because Linz tells us) that H will accept <H>
>>>> <H>
>>>> if H halts on <H> and that H will reject <H> <H> if H does not halt on
>>>> <H>, but he does not care which of these is the case because <H> is not
>>>> the representation of an instance of the halting problem.
>>>>
>>>> You could have asked PO why he cares what H does when given a string
>>>> like <H> that does not represent an HP instance (but he'd have no idea
>>>> what you were asking),
>>>
>>> // *The self-contradictory version of H*
>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn   // Ȟ applied to ⟨Ȟ⟩ does not halt
>>
>> You have completely ignored what Ben wrote. Well done.
>>
>
> *I appreciate that Ben is here*
>
> He understood that my syntax was correct.
> He seemed to make one mistake.
>
> He tried to get away with saying that I don't
> understand things so here I prove otherwise
> as shown above by:
>
> *H and its self-contradictory*
> *version Ȟ prove that I am correct*
>

No, the fact that you claim they are "vversions" of each other just
proves you don't know what yo0u are talking about and is an admission
that you are just a version of Donald Trump.

On 2/19/2024 3:03 AM, Mikko wrote:
> On 2024-02-18 17:57:20 +0000, olcott said:
>
>> On 2/18/2024 11:55 AM, Mikko wrote:
>>> On 2024-02-18 17:39:17 +0000, olcott said:
>>>
>>>> On 2/18/2024 11:22 AM, Mikko wrote:
>>>>> On 2024-02-18 15:27:38 +0000, olcott said:
>>>>>
>>>>>> On 2/18/2024 4:46 AM, Mikko wrote:
>>>>>>> On 2024-02-17 14:59:34 +0000, olcott said:
>>>>>>>
>>>>>>>> On 2/17/2024 4:08 AM, Mikko wrote:
>>>>>>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>>>>>>
>>>>>>>>>> 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".
>>>>>>>>>
>>>>>>>>> What follows the words "applied to" must specify an input to the
>>>>>>>>> Turing machine identified before those words. Linz does not say
>>>>>>>>> what H is expected to do if the input is not a pair of
>>>>>>>>> descritions,
>>>>>>>>> a Turing machine and a tape content. Therefore, whoever says
>>>>>>>>> "H applied to <H>" must tell what that means, in particular,
>>>>>>>>> whether H may answer something else that "yes" or "not".
>>>>>>>>>
>>>>>>>>
>>>>>>>> Maybe you should read Linz
>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>>>>>
>>>>>>>> Linz uses Wm as the TM description of M
>>>>>>>>
>>>>>>>> // Verbatim Linz Turing machine H --- M applied to w
>>>>>>>> // --- Does M halt on w?
>>>>>>>> H.q0 Wm w ⊢* H.qy // M applied to w halts
>>>>>>>> H.q0 Wm w ⊢* H.qn // M applied to w does not halt
>>>>>>>
>>>>>>> A particular caseof this is
>>>>>>>
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>>>>>
>>>>>>> which you said above. However, Linz does not specify whether
>>>>>>> H applied to <H> should halt or not, as the input is not in
>>>>>>> the domain of H, so nothing can be inferred from this case,
>>>>>>> which therefore is uninteresting.
>>>>>>>
>>>>>>
>>>>>> "Turing machine H will halt with either a yes or no answer.
>>>>>> We achieve this by asking that H halt in one of two
>>>>>> corresponding final states, say, qy or qn."
>>>>>> https://liarparadox.org/Peter_Linz_HP(Pages_318-319).pdf
>>>>>
>>>>> Your quote is wrong. A partial sentence should not be quoted
>>>>> without a good reason and when there q good reason to omit
>>>>> a part of a sentence the omission should be clearly indicated
>>>>> (usually with trhree dots).
>>>>>
>>>>
>>>> There cannot possibly be any context that would not be
>>>> self-contradictory thus context is irrelevant.
>>>
>>> Every part of the sentence is essential, otherwise it would not
>>> be included in that sentence.
>>>
>>> If a part of a sentence is omitted without an indication of omission
>>> that is usually considered a lie.
>>>
>>
>> It is common knowledge that a halt deciders must
>> always halt thus your whole issue was always moot.
>
> As I said, by usual convetions you lied when you quoted a part of a
> sentence without an indication that a part of the sentence was not
> quoted. Nice to see that you don't disagree.
>
<sarcasm>
Yes and I equally lie when I quote no one one say that water is H2O
</sarcasm>

--
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 6:48 AM, Richard Damon wrote:
> On 2/19/24 12:58 AM, olcott wrote:
>> On 2/18/2024 8:38 PM, immibis wrote:
>>> On 19/02/24 01:09, olcott wrote:
>>>> On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
>>>>> Mikko <mikko.levanto@iki.fi> writes:
>>>>>
>>>>>> On 2024-02-16 19:54:06 +0000, Ben Bacarisse said:
>>>>>>
>>>>>>> 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".
>>>>>>
>>>>>> What follows the words "applied to" must specify an input to the
>>>>>> Turing machine identified before those words. Linz does not say
>>>>>> what H is expected to do if the input is not a pair of descritions,
>>>>>> a Turing machine and a tape content. Therefore, whoever says
>>>>>> "H applied to <H>" must tell what that means,
>>>>>
>>>>> Linz tells us that "<M> w" is accepted by H (i.e. H transitions to qy)
>>>>> if M halts on input w.  Therefore Linz is telling us that H accepts
>>>>> "<H>
>>>>> <H>" if H applied to <H> halts.  All PO has done is substitute H for M
>>>>> and <H> for w.  That's valid, even in Linz's rather vague notion of
>>>>> the
>>>>> exact strings involved.  M is any TM, so substituting H (were it to
>>>>> exist) is a reasonable thing to do.  And w can be any string, so there
>>>>> is nothing to stop PO substituting <H> for w.
>>>>>
>>>>> So there is no doubt about what the phrase means.  H will go through
>>>>> some unknown sequence of transitions when run with <H> on the
>>>>> tape.  It
>>>>> most certainly will or will not halt even though the input is not
>>>>> in the
>>>>> problem domain.
>>>>
>>>> *The input <is> in the problem domain*
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn  // H applied to ⟨H⟩ does not halt
>>>>
>>>> The Turing machine description of an element of the infinite
>>>> set of Turing machines defined by the Linz template is not
>>>> in the domain of a halt decider?
>>>>
>>>> ⊢* a finite number of one or more state transitions
>>>> Linz: "an arbitrary number of moves"
>>>>
>>>>>> in particular,
>>>>>> whether H may answer something else that "yes" or "not".
>>>>>
>>>>> That's asking way more than what the phrase means!  It's not entirely
>>>>> clear what you mean be "answer" here, but Linz's TMs always do one
>>>>> three
>>>>> things for any input: they accept, they reject or they don't halt.
>>>>> I'd
>>>>> call the first two an "answer", but a TM (and H in particular) does
>>>>> not
>>>>> give and answer on all inputs.
>>>>>
>>>>> Linz does not say (and he does not care) what H might do when
>>>>> presented
>>>>> with <H> on the tape because in his presentation only some strings
>>>>> (though sadly not an exactly defined set of strings) are in the
>>>>> problem
>>>>> domain.  We /can/ say (because Linz tells us) that H will accept
>>>>> <H> <H>
>>>>> if H halts on <H> and that H will reject <H> <H> if H does not halt on
>>>>> <H>, but he does not care which of these is the case because <H> is
>>>>> not
>>>>> the representation of an instance of the halting problem.
>>>>>
>>>>> You could have asked PO why he cares what H does when given a string
>>>>> like <H> that does not represent an HP instance (but he'd have no idea
>>>>> what you were asking),
>>>>
>>>> // *The self-contradictory version of H*
>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qy ∞ // Ȟ applied to ⟨Ȟ⟩ halts
>>>> Ȟ.q0 ⟨Ȟ⟩ ⟨Ȟ⟩ ⊢* Ȟ.qn   // Ȟ applied to ⟨Ȟ⟩ does not halt
>>>
>>> You have completely ignored what Ben wrote. Well done.
>>>
>>
>> *I appreciate that Ben is here*
>>
>> He understood that my syntax was correct.
>> He seemed to make one mistake.
>>
>> He tried to get away with saying that I don't
>> understand things so here I prove otherwise
>> as shown above by:
>>
>> *H and its self-contradictory*
>> *version Ȟ prove that I am correct*
>>
>
> No, the fact that you claim they are "vversions" of each other just
> proves you don't know what yo0u are talking about and is an admission
> that you are just a version of Donald Trump.

Ȟ is exactly the Linz H template with an infinite loop appended to its
accept state. Making it exactly the same as the Linz H template except
now the self-reference of Linz H also becomes self-contradiction.

You are trying to use deception to show that two TM templates
that differ by a single appended infinite loop differ by more
than a single appended infinite loop.

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