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

[olcott]

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

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

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

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

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

[Mikko]

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

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

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

--
Mikko

[Ben Bacarisse]

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

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

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

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

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

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

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

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

--
Ben.

[olcott]

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

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

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

// Linz Turing machine H --- H applied to ⟨H⟩
// --- Do you halt on your own Turing Machine description ?

H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // Condition1: *H applied to ⟨H⟩ halts*
H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // Condition2: *H applied to ⟨H⟩ does not halt*
*H applied to ⟨H⟩ ⟨H⟩ correctly transitions to H.qy*

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

--

[Richard Damon]

On 2/16/24 1:07 AM, olcott wrote:
> // Linz Turing machine H --- M applied to w
> // --- Does M halts on w?
> H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
> H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt

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

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

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

>
> Linz H' is merely the self-contradictory form of Linz H applied to ⟨H⟩
>
> // Linz Turing machine H' ---  H' applied to ⟨H'⟩
> // --- Do you halt on your own Turing Machine description ?
> H'.q0 ⟨H'⟩ ⟨H'⟩ ⊢* H'.qy ∞ // H' applied to ⟨H'⟩ halts
> H'.q0 ⟨H'⟩ ⟨H'⟩ ⊢* H'.qn     // H' applied to ⟨H'⟩ does not halt
>

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

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

[Mikko]

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

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

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

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

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

--
Mikko

[olcott]

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

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

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

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

[Mikko]

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

--
Mikko

[olcott]

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

[Ben Bacarisse]

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

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

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

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

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

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

--
Ben.

[olcott]

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

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

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

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

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

[Richard Damon]

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

[Richard Damon]

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

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

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

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

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

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

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

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

[Richard Damon]

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

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

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

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

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

There is nothing problimatic about that.

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

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

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

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

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

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

[olcott]

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

[olcott]

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

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

[Richard Damon]

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

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

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

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

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

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

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

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

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

[Richard Damon]

Excpet that it DOES know enough.

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

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

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

[olcott]

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

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

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

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

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

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

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

[olcott]

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

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

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

Can you see how stupid this isomorphic rebuttal is?

[Richard Damon]

Why do you say that?

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

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

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

Seems par for the course.

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

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

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

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

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

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

[olcott]

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

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

[immibis]

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

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

[Richard Damon]

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

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

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

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

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

[Richard Damon]

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

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

Nope.

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


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

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

[immibis]

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.

[Mikko]

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

[olcott]

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

[Richard Damon]

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.

[immibis]

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.

[olcott]

I made the mistake of giving H one param instead of two
when I was converting it to report on itself.

[Mikko]

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

[olcott]

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

[olcott]

On 2/18/2024 11:22 AM, Mikko wrote:

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

[Mikko]

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

[olcott]

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

[Richard Damon]

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.

[immibis]

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

[Ben Bacarisse]

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.

[olcott]

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

--

[Richard Damon]

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.

[olcott]

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

[Richard Damon]

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.

[immibis]

You have completely ignored what Ben wrote. Well done.

[olcott]

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

[Mikko]

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

[Ben Bacarisse]

immibis <ne...@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.

[Richard Damon]

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.

[olcott]

<sarcasm>
Yes and I equally lie when I quote no one one say that water is H2O
</sarcasm>

[olcott]

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