Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.c++ > #122802 > unrolled thread

Conventional notion of the HP diagonal case is succinctly proven unsatisfiable

Back to article view | Back to comp.lang.c++

Contents

  Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-02 15:59 -0500
    Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable dbush <dbush.mobile@gmail.com> - 2025-10-02 17:19 -0400
      Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-02 16:56 -0500
        Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Richard Damon <Richard@Damon-Family.org> - 2025-10-05 16:46 -0400
    Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-02 23:31 +0000
      Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-02 18:40 -0500
        Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-02 23:54 +0000
          Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-02 19:35 -0500
            Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-03 21:50 +0000
              Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-03 17:01 -0500
                Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-10-03 15:06 -0700
              Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-03 17:06 -0500
                Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-03 23:25 +0000
                  Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-03 18:57 -0500
                    Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-04 05:02 +0000
                      Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-04 07:56 -0500
                        Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Richard Heathfield <rjh@cpax.org.uk> - 2025-10-04 16:01 +0100
                          Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-04 10:20 -0500
                            Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-04 15:36 +0000
                              Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-04 11:35 -0500
                                Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Kaz Kylheku <643-408-1753@kylheku.com> - 2025-10-04 16:49 +0000
                                  Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-05 07:52 -0500
                            Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Richard Heathfield <rjh@cpax.org.uk> - 2025-10-04 17:44 +0100
                      Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-10-04 15:32 +0100
    Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Wuns Haerst <Wuns.Haerst@wurstfabrik.at> - 2025-10-04 17:23 +0200
      Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-04 10:25 -0500
      Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable olcott <polcott333@gmail.com> - 2025-10-04 10:27 -0500
    Re: Conventional notion of the HP diagonal case is succinctly proven unsatisfiable Richard Damon <Richard@Damon-Family.org> - 2025-10-05 16:46 -0400

Page 1 of 2  [1] 2  Next page →

#122802 — Conventional notion of the HP diagonal case is succinctly proven unsatisfiable

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.

Finally a simple way to say it that uses terms exactly correctly.

*** NOTE *** THIS IS ONLY THE CONVENTIONAL NOTION

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

[toc] | [next] | [standalone]

#122803

On 10/2/2025 4:59 PM, olcott wrote:
> void P()
> {
>    if H(P)  // returns 1 for halts 0 for loops
>      HERE: goto HERE;
> }
> 
> For *any* decider H and input P

Category error.  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.  H(P) gives the incorrect answer.

[toc] | [prev] | [next] | [standalone]

#122804

On 10/2/2025 4:19 PM, dbush wrote:
> On 10/2/2025 4:59 PM, olcott wrote:
>> void P()
>> {
>>    if H(P)  // returns 1 for halts 0 for loops
>>      HERE: goto HERE;
>> }
>>
>> For *any* decider H and input P
> 
> Category error.  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.  H(P) gives the incorrect answer.
> 


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

[toc] | [prev] | [next] | [standalone]

#122830

On 10/2/25 5:56 PM, olcott wrote:
> On 10/2/2025 4:19 PM, dbush wrote:
>> On 10/2/2025 4:59 PM, olcott wrote:
>>> void P()
>>> {
>>>    if H(P)  // returns 1 for halts 0 for loops
>>>      HERE: goto HERE;
>>> }
>>>
>>> For *any* decider H and input P
>>
>> Category error.  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*

And how does P call a "set"?

You end up with a set of H/P pairs, each H a specific program, and P the 
version built on it that it also the P that H is given.

And then, EVERY P has a correct answer, and every H doesn't give it.

> 
> For *any* decider H and input P
> *is an infinite set of H/P pairs*

All of which (the deciders) are wrong, and all the input HAVE a correct 
answer to the halting question.

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

And changing the meaning of the question of the problme, just makes you 
a lying fraud.

> 
>> 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.  H(P) gives the incorrect answer.
>>
> 
> 

[toc] | [prev] | [next] | [standalone]

#122805

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.
The diagonal is an ifninite number of cells running through
a table.

Each case is different. For each i from 0 to infinity, Pi is
a different case which calls Hi.

  // Diagonal case 1
  void P1()
  {
     if H1(P1)
       HERE: goto HERE;
  }
 
  // Diagonal case 2
  void P2()
  {
     if H2(P2) // different case, different code!
       HERE: goto HERE;
  }

  // Diagonal case 3
  void P3()
  {
     if H3(P3) // different case again, different code!
       HERE: goto HERE;
  }

  // Diagonal case 4
  void P4() { .... H4(P4) ... }
  // Diagonal case 4
  void P5() { .... }
  // ...

There isn't a single P that is not satisfiable. There are
multiple Pi's each of which is shown not to be solved
correctly by its /respective/ Hi.

Everyone of these Pi's has a definite halting status,

It's possible for Hj(Pi) to give a correct answer,
as long as j != i. When j == i, we are on the diagonal:
we have H7(P7), or H129(P129) ...

Do you finally understand it?

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#122806

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

More clearly stated as the infinite set of H/P pairs


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

[toc] | [prev] | [next] | [standalone]

#122807

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.

You need, "For all rows of the table i, Hi does not correctly
decide the corresponding case Pi in column i".

We quantify just one independent variable; the other is dependent. Pi is
built on Hi; it is dependent.

If we quantify over H, we cannot quantify over /any/ P; it is pinned
We choose a Hi, go to the diagonal in H's row, and then in that
column we find Pi.

You keep insisting that nobody is looking at the details
of what you are saying, but your details are sloppy as hell,
which raises the suspicion that you don't understand things.

People who understand a subject show it by being crisply accurate
in all their details (except teaching the subject to those who are
missing a chunk of background, needing to simplify certain aspects).

The reason you are not a good communicator, as you have acknowledged,
is that you don't know the subject matter. Your writing about stuff
you know is decent enough.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#122808

On 10/2/2025 6:54 PM, Kaz Kylheku wrote:
> 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.
> 

I have a concept. It is a valid concept
you refuse all names of the concept.
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.


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

[toc] | [prev] | [next] | [standalone]

#122811

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.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#122812

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.



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

[toc] | [prev] | [next] | [standalone]

#122814

On 10/3/2025 3:01 PM, olcott 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.
>>
> 
> 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.

What does P say? Does it halt or not. You can't have an H in there 
telling it what to do, or not do?

[toc] | [prev] | [next] | [standalone]

#122813

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.

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

[toc] | [prev] | [next] | [standalone]

#122815

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

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#122816

On 10/3/2025 6:25 PM, Kaz Kylheku wrote:
> 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.
> 

My words may have seemed to have indicated that.

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

Yes that is why I coined the term pathological
self-reference(Olcott 2004). All my old posts
are still out there. I can still directly reply to them.

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

None-the-less it is still semantically faulty.

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

Is much more liar paradox like.
The pathological self-reference(Olcott 2004)
is indirect instead of direct.

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


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

[toc] | [prev] | [next] | [standalone]

#122817

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.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#122818

On 10/4/2025 12:02 AM, Kaz Kylheku wrote:
> 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):
> 

How is it that you can disagree with verified facts?

Iterate over the set of H decider and P input
pairs where
If H says halts then P loops
If H says loops then P halts
Making whatever each H says incorrect.

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


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

[toc] | [prev] | [next] | [standalone]

#122820

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>


-- 
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

[toc] | [prev] | [next] | [standalone]

#122821

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. In every other case they are the same.

> and yet 
> here you are.
> 
> <snip>
> 
> 


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

[toc] | [prev] | [next] | [standalone]

#122825

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.

The machine D specifies a behavior D() which is absolutely
the same.

... and so, to reiterate, that's how it goes when a pathetic crank
disagrees with verified facts.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#122826

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.

There are no number recursive simulations where ⟨Ĥ⟩ ⟨Ĥ⟩
correctly simulated by embedded_H would ever
(a) Stop running without being aborted
(b) Reach its own simulated final halt state of ⟨Ĥ.qn⟩

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, // accept state
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // reject state
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩


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

[toc] | [prev] | [next] | [standalone]

Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.lang.c++

csiph-web