| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 26 |
| Nodes: | 6 (1 / 5) |
| Uptime: | 18:38:48 |
| Calls: | 629 |
| Files: | 1,186 |
| D/L today: |
18 files (29,890K bytes) |
| Messages: | 167,605 |
void P()
{
-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a HERE: goto HERE;
}
For *any* decider H and input P
On 10/2/2025 4:59 PM, olcott wrote:
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For *any* decider H and input P
Category error.-a The fixed immutable set of instructions known as H does one thing and one thing only.
Likewise, the fixed immutable set of
instructions known as P does one thing and one thing only.
So P either halts or does not halt.-a H(P) gives the incorrect answer.
void P()
{
if H(P) // returns 1 for halts 0 for loops
HERE: goto HERE;
}
For *any* decider H and input P
If H says halts then P loops
If H says loops then P halts
Making this HP diagonal case unsatisfiable.
On 2025-10-02, olcott <polcott333@gmail.com> wrote:
void P()
{
if H(P) // returns 1 for halts 0 for loops
HERE: goto HERE;
}
For *any* decider H and input P
If H says halts then P loops
If H says loops then P halts
Making this HP diagonal case unsatisfiable.
You stil don't get it: there isn't one diagonal case.
On 10/2/2025 6:31 PM, Kaz Kylheku wrote:
On 2025-10-02, olcott <polcott333@gmail.com> wrote:
void P()
{
if H(P) // returns 1 for halts 0 for loops
HERE: goto HERE;
}
For *any* decider H and input P
If H says halts then P loops
If H says loops then P halts
Making this HP diagonal case unsatisfiable.
You stil don't get it: there isn't one diagonal case.
You still didn't pay close enough attention.
For *any* decider H and input P
On 2025-10-02, olcott <polcott333@gmail.com> wrote:
On 10/2/2025 6:31 PM, Kaz Kylheku wrote:
On 2025-10-02, olcott <polcott333@gmail.com> wrote:
void P()
{
if H(P) // returns 1 for halts 0 for loops
HERE: goto HERE;
}
For *any* decider H and input P
If H says halts then P loops
If H says loops then P halts
Making this HP diagonal case unsatisfiable.
You stil don't get it: there isn't one diagonal case.
You still didn't pay close enough attention.
For *any* decider H and input P
But, literally, if you have the quantification "for any decider H and
any input P", you are spanning the entire table, not just the diagonal!
So your argumentation is then wrong.
This concept must be named or it cannot
be referenced. I must reference it.
It must be a simple and accurate name.
WTF would you call it?
The set of H/P pairs such that:
For decider H and input P
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
This concept must be named or it cannot
be referenced. I must reference it.
It must be a simple and accurate name.
WTF would you call it?
The set of H/P pairs such that:
For decider H and input P
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
This is not /your/ concept; it is something you should have
understood properly 20 years ago.
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
This concept must be named or it cannot
be referenced. I must reference it.
It must be a simple and accurate name.
WTF would you call it?
The set of H/P pairs such that:
For decider H and input P
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
This is not /your/ concept; it is something you should have
understood properly 20 years ago.
On 10/3/2025 4:50 PM, Kaz Kylheku wrote:
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
This concept must be named or it cannot
be referenced. I must reference it.
It must be a simple and accurate name.
WTF would you call it?
The set of H/P pairs such that:
For decider H and input P
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
This is not /your/ concept; it is something you should have
understood properly 20 years ago.
I did understand that 22 years ago by the
conventional long winded form.
*Here is the less clumsy rewrite*
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
On 10/3/2025 4:50 PM, Kaz Kylheku wrote:
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
This concept must be named or it cannot
be referenced. I must reference it.
It must be a simple and accurate name.
WTF would you call it?
The set of H/P pairs such that:
For decider H and input P
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
This is not /your/ concept; it is something you should have
understood properly 20 years ago.
It isn't that I didn't understand this 22 years ago.
I understood this the whole time. It is that 22 years
ago I spotted its bogus liar paradox structure.
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
On 10/3/2025 4:50 PM, Kaz Kylheku wrote:
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
This concept must be named or it cannot
be referenced. I must reference it.
It must be a simple and accurate name.
WTF would you call it?
The set of H/P pairs such that:
For decider H and input P
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
This is not /your/ concept; it is something you should have
understood properly 20 years ago.
It isn't that I didn't understand this 22 years ago.
I understood this the whole time. It is that 22 years
As little as five years go or so you still believed that there
is supposed to be a /single/ case that is undecidable.
ago I spotted its bogus liar paradox structure.
Because you didn't understand it at the time, but given what you should
know now, you should see that it's not the same at all.
The diagonal case, though it contains a self-reference, is not a truth statement and it is not asserting its own falsehood.
The details of the self-reference matter.
For instance, these sentence are just as self-referential as the
Liar Paradox, yet we can cheerfully assign them truth values:
This sentence has five words. (True)
This sentence has four words. (False)
Like the Liar sentence, these sentences are making a logical assertion. Unlike the Liar sentence, they are not simply making a logical assertion about their truth value; they are making an assertion about a property different from their truth value.
By talking about something other than their own truth value, the
logical assertion is anchored to something external.
The following sentence is self-referential, yet talks about nothing but
its truth value:
This sentence is true.
this is still just internal: the logical assertion talking about its
own truth. We can assign the value True or False to this sentence
without contradiction---but that is a problem almost if not just as bad
as not being able to assign a truth value!
So anyway, in the diagonal trick used for reasoning about halting,
the self-reference is much more like:
This sentence has four words.
than it is like:
This sentence is false.
The H decider isn't asserting something about the truth value of its
subject; it is anchored to a different property, halting,
which is like word count, or any other property.
The "opposite behavior" is something as if we could make
a sentence that changes its word count to something other than
what it has been counted by some procedure.
Suppose H is a word count procedure. Let the sentence D be:
In this sentence, 'Church-Turing' is two words, except if H says
that this sentence has an even number of words, in which case it
is one word.
Thus if we allow sentences to stipulate how many words comprise a
hyphenated compound which occurs in them, and if we allow such
stipulations to refer to word counting functions, then the word count function becomes incomputable. :)
On 10/3/2025 6:25 PM, Kaz Kylheku wrote:
So anyway, in the diagonal trick used for reasoning about halting,
the self-reference is much more like:
This sentence has four words.
than it is like:
This sentence is false.
Incorrect.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
On 10/3/2025 6:25 PM, Kaz Kylheku wrote:
So anyway, in the diagonal trick used for reasoning about halting,
the self-reference is much more like:
This sentence has four words.
than it is like:
This sentence is false.
Incorrect.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Nope, it's like (from my Lisp session):
7> (len "This string has thirty-eight characters")
39
Oops, the sentence is wrong; let's fix it to "nine":
8> (len "This string has thirty-nine characters")
38
Oops, now it's thirty-eight like it said originally ...
But we can just regard either sentence as incorrect and be done with it; there is no issue assigning a truth value.
The sentence is talking self-referentially about a property other than
its truth value, so the pathological ingredient from the Liar Paradox is absent.
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
On 10/3/2025 6:25 PM, Kaz Kylheku wrote:
So anyway, in the diagonal trick used for reasoning about halting,
the self-reference is much more like:
This sentence has four words.
than it is like:
This sentence is false.
Incorrect.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Nope, it's like (from my Lisp session):
7> (len "This string has thirty-eight characters")
39
Oops, the sentence is wrong; let's fix it to "nine":
8> (len "This string has thirty-nine characters")
38
Oops, now it's thirty-eight like it said originally ...
But we can just regard either sentence as incorrect and be done with it; there is no issue assigning a truth value.
The sentence is talking self-referentially about a property other than
its truth value, so the pathological ingredient from the Liar Paradox is absent.
On 10/4/2025 12:02 AM, Kaz Kylheku wrote:
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Nope, it's like (from my Lisp session):
How is it that you can disagree with verified facts?
On 04/10/2025 13:56, olcott wrote:
On 10/4/2025 12:02 AM, Kaz Kylheku wrote:
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
<snip>
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Nope, it's like (from my Lisp session):
How is it that you can disagree with verified facts?
The incomputability of the Halting Problem is a verified fact,
and yet
here you are.
<snip>
void P()
{
-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a HERE: goto HERE;
}
For *any* decider H and input P
If H says halts then P loops
If H says loops then P halts
Making this HP diagonal case unsatisfiable.
Finally a simple way to say it that uses terms exactly correctly.
*** NOTE *** THIS IS ONLY THE CONVENTIONAL NOTION
Am 02.10.2025 um 22:59 schrieb olcott:
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For *any* decider H and input P
If H says halts then P loops
If H says loops then P halts
Making this HP diagonal case unsatisfiable.
Wrong !
Finally a simple way to say it that uses terms exactly correctly.
*** NOTE *** THIS IS ONLY THE CONVENTIONAL NOTION
Am 02.10.2025 um 22:59 schrieb olcott:
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For *any* decider H and input P
If H says halts then P loops
If H says loops then P halts
Making this HP diagonal case unsatisfiable.
Wrong !
On 10/4/2025 10:01 AM, Richard Heathfield wrote:
On 04/10/2025 13:56, olcott wrote:
On 10/4/2025 12:02 AM, Kaz Kylheku wrote:
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
<snip>
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Nope, it's like (from my Lisp session):
How is it that you can disagree with verified facts?
The incomputability of the Halting Problem is a verified fact,
Within the premise that H must report on the behavior of D.
yet not when H reports on the behavior specified by its input D.
The behavior of D and the behavior of the input D are not
the same when an input calls its own simulating termination
analyzer.
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 10:01 AM, Richard Heathfield wrote:
On 04/10/2025 13:56, olcott wrote:
On 10/4/2025 12:02 AM, Kaz Kylheku wrote:
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
<snip>
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Nope, it's like (from my Lisp session):
How is it that you can disagree with verified facts?
The incomputability of the Halting Problem is a verified fact,
Within the premise that H must report on the behavior of D.
yet not when H reports on the behavior specified by its input D.
So, there you go that is the answer to "how is it that you can disagree
with verified facts"; you spew nonsensical, cranky garbage in which it supposed to be understood that "the behavior specified by its input D"
and "the behavior of D" are magically two different entities.
Magical thinking.
The behavior of D and the behavior of the input D are not
the same when an input calls its own simulating termination
analyzer.
Then that termination analyzer is obviously incorrect.
On 10/4/2025 10:01 AM, Richard Heathfield wrote:
On 04/10/2025 13:56, olcott wrote:
How is it that you can disagree with verified facts?
The incomputability of the Halting Problem is a verified fact,
On 10/4/2025 10:36 AM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 10:01 AM, Richard Heathfield wrote:
On 04/10/2025 13:56, olcott wrote:
On 10/4/2025 12:02 AM, Kaz Kylheku wrote:
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
<snip>
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Nope, it's like (from my Lisp session):
How is it that you can disagree with verified facts?
The incomputability of the Halting Problem is a verified fact,
Within the premise that H must report on the behavior of D.
yet not when H reports on the behavior specified by its input D.
So, there you go that is the answer to "how is it that you can disagree
with verified facts"; you spew nonsensical, cranky garbage in which it
supposed to be understood that "the behavior specified by its input D"
and "the behavior of D" are magically two different entities.
Magical thinking.
The behavior of D and the behavior of the input D are not
the same when an input calls its own simulating termination
analyzer.
Then that termination analyzer is obviously incorrect.
That you still don't understand that embedded_H is
correct when it reports on the recursive simulation
behavior of its correct partial simulation of its
input is not my mistake.
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 10:36 AM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 10:01 AM, Richard Heathfield wrote:
On 04/10/2025 13:56, olcott wrote:
On 10/4/2025 12:02 AM, Kaz Kylheku wrote:
On 2025-10-03, olcott <polcott333@gmail.com> wrote:
<snip>
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Nope, it's like (from my Lisp session):
How is it that you can disagree with verified facts?
The incomputability of the Halting Problem is a verified fact,
Within the premise that H must report on the behavior of D.
yet not when H reports on the behavior specified by its input D.
So, there you go that is the answer to "how is it that you can disagree
with verified facts"; you spew nonsensical, cranky garbage in which it
supposed to be understood that "the behavior specified by its input D"
and "the behavior of D" are magically two different entities.
Magical thinking.
The behavior of D and the behavior of the input D are not
the same when an input calls its own simulating termination
analyzer.
Then that termination analyzer is obviously incorrect.
That you still don't understand that embedded_H is
correct when it reports on the recursive simulation
I specifically understand that it is incorrect.
behavior of its correct partial simulation of its
input is not my mistake.
The partial simulation specifies termination. (It has to, otherwise it
is not a correct simulation of the correct input.)
On 10/2/2025 4:19 PM, dbush wrote:
On 10/2/2025 4:59 PM, olcott wrote:
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For *any* decider H and input P
Category error.-a The fixed immutable set of instructions known as H
does one thing and one thing only.
*That is why I changed it to a set of sets*
For *any* decider H and input P
*is an infinite set of H/P pairs*
Almost every error that anyone has ever pointed
out is either their own lack of attention or their
own lack of comprehension.
The very helpful error corrections are wording mistakes.
That is why I need reviewers like you.
Likewise, the fixed immutable set of instructions known as P does one
thing and one thing only.
So P either halts or does not halt.-a H(P) gives the incorrect answer.
void P()
{
-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a HERE: goto HERE;
}
For *any* decider H and input P
If H says halts then P loops
If H says loops then P halts
Making this HP diagonal case unsatisfiable.
Finally a simple way to say it that uses terms exactly correctly.
*** NOTE *** THIS IS ONLY THE CONVENTIONAL NOTION