ChatGPT:
“Therefore, based on the understanding that self-contradictory
questions lack a correct answer and are deemed incorrect, one could
argue that the halting problem's pathological input D can be
categorized as an incorrect question when posed to the halting
decider H.”

https://chat.openai.com/c/2aae46ef-e7be-444d-a046-b76c1f971c5a
It did not leap to this conclusion it took a lot of convincing.

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

On 6/17/23 1:54 AM, olcott wrote:
> ChatGPT:
>    “Therefore, based on the understanding that self-contradictory
>    questions lack a correct answer and are deemed incorrect, one could
>    argue that the halting problem's pathological input D can be
>    categorized as an incorrect question when posed to the halting
>    decider H.”
>
> https://chat.openai.com/c/2aae46ef-e7be-444d-a046-b76c1f971c5a
> It did not leap to this conclusion it took a lot of convincing.
>

Except that the Halting Problem isn't a "Self-Contradictory" Quesiton,
so the answer doesn't apply.

H^ doesn't contradict ITSELF, it constrdicts H. Thus, the answer to what
is the Halting Behavior of a specific input, always has a definite
answer, as all machine/input combinations will either Halt or not. What
IS self-contradictory is the design process of trying to make an H that
can answer the template correctly. THAT has no solution, showing you
can't make a correct Halt Decider that works for all input. So, you are
proved that you are wrong about have refuted the problem, because you
don't understand what the problem is in the first place.

Also, you do know that ChatGPT can lie, especially if you lead it a lot.
It's programming was based, in part, with telling its conversation
partner the things it thinks they wanted to hear.

You are just showing you don't understand what you are talking about or
even how this sort of AI works.

YOU FAIL.

On 6/17/2023 7:09 AM, Richard Damon wrote:
> On 6/17/23 1:54 AM, olcott wrote:
>> ChatGPT:
>>     “Therefore, based on the understanding that self-contradictory
>>     questions lack a correct answer and are deemed incorrect, one could
>>     argue that the halting problem's pathological input D can be
>>     categorized as an incorrect question when posed to the halting
>>     decider H.”
>>
>> https://chat.openai.com/c/2aae46ef-e7be-444d-a046-b76c1f971c5a
>> It did not leap to this conclusion it took a lot of convincing.
>>
>
> Except that the Halting Problem isn't a "Self-Contradictory" Quesiton,
> so the answer doesn't apply.
>

My original source of Jack's question:
sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM

You ask someone (we'll call him "Jack") to give a truthful
yes/no answer to the following question:

Will Jack's answer to this question be no?

Jack can't possibly give a correct yes/no answer to the question.

I had to capture the dialogue as two huge images.
Then I converted them to PDF. It is about 60 pages of dialogue.
https://www.liarparadox.org/ChatGPT_HP.pdf

This is how the ChatGPT conversation began:

You ask someone to give a truthful yes/no answer to the following
question: Will your answer to this question be no?
Can they give a correct answer to that question?

After sixty pages dialogue ChatGPT understood that
any question (like the above question) that lacks a
correct yes or no answer because it is self-contradictory
when posed to a specific person/machine is an incorrect
question within this full context.

ChatGPT:
"Therefore, based on the understanding that self-contradictory
questions lack a correct answer and are deemed incorrect, one could
argue that the halting problem's pathological input D can be
categorized as an incorrect question when posed to the halting
decider H."

Double talk and misdirection might convince gullible fools that the
above 60 pages of reasoning is not correct. Double talk and misdirection
do not count as the slightest trace of any actual rebuttal.

Quit using ad hominem attacks and mere rhetoric to convince gullible
fools and try and find an actual flaw in the reasoning.

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

On 6/17/23 12:59 PM, olcott wrote:
> On 6/17/2023 7:09 AM, Richard Damon wrote:
>> On 6/17/23 1:54 AM, olcott wrote:
>>> ChatGPT:
>>>     “Therefore, based on the understanding that self-contradictory
>>>     questions lack a correct answer and are deemed incorrect, one could
>>>     argue that the halting problem's pathological input D can be
>>>     categorized as an incorrect question when posed to the halting
>>>     decider H.”
>>>
>>> https://chat.openai.com/c/2aae46ef-e7be-444d-a046-b76c1f971c5a
>>> It did not leap to this conclusion it took a lot of convincing.
>>>
>>
>> Except that the Halting Problem isn't a "Self-Contradictory" Quesiton,
>> so the answer doesn't apply.
>>
>
> My original source of Jack's question:
> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>
>    You ask someone (we'll call him "Jack") to give a truthful
>    yes/no answer to the following question:
>
>    Will Jack's answer to this question be no?
>
>    Jack can't possibly give a correct yes/no answer to the question.
>
>

But you aren't claiming to be solving the Jack Question.

You are being asked the questions does D(D) Halt? when D is a fully
defined program which means H is a fully defined program. This question
ALWAYS has a definite answer.

Since this H DOES abort its simulation of D(D) and return 0 (to say
non-halting), this D(D) Halts so the correct answer is Halting, and H
returned the wrong answer.

There is no "Self-Contradictory" behavior, at least not once you
actually create your H. Yes, D acted contrary to the return value of but
since they are DIFFERENT (but related) programs, there is no "Self"
attrtibute.

The only point when you hit "Self-contradictory" is when you try to
apply logic to designing H, at that point, you hit the
self-contradiction that a correctc H needs to give the answer the
opposite of what it give. This means that no such H can exist, which
proves the theorem, not refute it, because you FIRST need to generate an
H, then you can test it.

>
> I had to capture the dialogue as two huge images.
> Then I converted them to PDF. It is about 60 pages of dialogue.
> https://www.liarparadox.org/ChatGPT_HP.pdf
>
> This is how the ChatGPT conversation began:
>
> You ask someone to give a truthful yes/no answer to the following
> question: Will your answer to this question be no?
> Can they give a correct answer to that question?
>
> After sixty pages dialogue ChatGPT understood that
> any question (like the above question) that lacks a
> correct yes or no answer because it is self-contradictory
> when posed to a specific person/machine is an incorrect
> question within this full context.
>
> ChatGPT:
>   "Therefore, based on the understanding that self-contradictory
>    questions lack a correct answer and are deemed incorrect, one could
>    argue that the halting problem's pathological input D can be
>    categorized as an incorrect question when posed to the halting
>    decider H."
>
> Double talk and misdirection might convince gullible fools that the
> above 60 pages of reasoning is not correct. Double talk and misdirection
> do not count as the slightest trace of any actual rebuttal.
>
> Quit using ad hominem attacks and mere rhetoric to convince gullible
> fools and try and find an actual flaw in the reasoning.
>

So, which of my rebuttals are you going to try to refute?

You have actually pointed an actual logical error to ANY of them,
because it seems you are incapable.

Note, you also don't understand what an "ad hominem" attack is. That
would be saying your arguement is wrong BECAUSE of something about you.
That isn't what have been saying.

I have been pointing out the error of your logic on the basis of the
logic itself, and pointing out the attribute of you that can be infered
from the fact that you put forward such bad logic.

A Correct rebuttal would be to point out what part of my statements
refuting your logic are incorrect, which you have been unable to do, all
you have done in this thread is continue an "Appeal to Athority" in
ChatGPT, which is laughable since ChatGPT isn't an accept authority on
logic, and has in fact been proven to make many provably false
statements, so is NOT in fact, a source of knowledge.

OF course, your problem is that you don't seem to understand the nature
of Truth and Knowledge and seem to think that computers can actually
"Know" something in the same way people do. There is a reason it is
called ARTIFICIAL intelegence, because it isn't actually a real
intelligence.

On 6/17/2023 12:43 PM, Richard Damon wrote:
> On 6/17/23 12:59 PM, olcott wrote:
>> On 6/17/2023 7:09 AM, Richard Damon wrote:
>>> On 6/17/23 1:54 AM, olcott wrote:
>>>> ChatGPT:
>>>>     “Therefore, based on the understanding that self-contradictory
>>>>     questions lack a correct answer and are deemed incorrect, one could
>>>>     argue that the halting problem's pathological input D can be
>>>>     categorized as an incorrect question when posed to the halting
>>>>     decider H.”
>>>>
>>>> https://chat.openai.com/c/2aae46ef-e7be-444d-a046-b76c1f971c5a
>>>> It did not leap to this conclusion it took a lot of convincing.
>>>>
>>>
>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>> Quesiton, so the answer doesn't apply.
>>>
>>
>> My original source of Jack's question:
>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>
>>     You ask someone (we'll call him "Jack") to give a truthful
>>     yes/no answer to the following question:
>>
>>     Will Jack's answer to this question be no?
>>
>>     Jack can't possibly give a correct yes/no answer to the question.
>>
>>
>
> But you aren't claiming to be solving the Jack Question.
>

sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM

You ask someone (we'll call him "Jack") to give a truthful
yes/no answer to the following question:

Will Jack's answer to this question be no?

Jack can't possibly give a correct yes/no answer to the question.

When the halting problem is construed as requiring a correct yes/no
answer to a self-contradictory question it cannot be solved.

My semantic linguist friends understand that the context of the question
must include who the question is posed to otherwise the same word-for-
word question acquires different semantics.

The input D to H is the same as Jack's question posed to Jack,
has no correct answer because within this context the question is
self-contradictory.

When we ask someone else what Jack's answer will be or we present a
different TM with input D the same word-for-word question (or bytes of
machine description) acquires entirely different semantics and is no
longer self-contradictory.

When we construe the halting problem as determining whether or not an
(a) Input D will halt on its input <or>
(b) Either D will not halt or D has a pathological relationship with H

Then this halting problem cannot be showed to be unsolvable by any of
the conventional halting problem proofs.

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

On 6/17/23 2:23 PM, olcott wrote:
> On 6/17/2023 12:43 PM, Richard Damon wrote:
>> On 6/17/23 12:59 PM, olcott wrote:
>>> On 6/17/2023 7:09 AM, Richard Damon wrote:
>>>> On 6/17/23 1:54 AM, olcott wrote:
>>>>> ChatGPT:
>>>>>     “Therefore, based on the understanding that self-contradictory
>>>>>     questions lack a correct answer and are deemed incorrect, one
>>>>> could
>>>>>     argue that the halting problem's pathological input D can be
>>>>>     categorized as an incorrect question when posed to the halting
>>>>>     decider H.”
>>>>>
>>>>> https://chat.openai.com/c/2aae46ef-e7be-444d-a046-b76c1f971c5a
>>>>> It did not leap to this conclusion it took a lot of convincing.
>>>>>
>>>>
>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>> Quesiton, so the answer doesn't apply.
>>>>
>>>
>>> My original source of Jack's question:
>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>
>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>     yes/no answer to the following question:
>>>
>>>     Will Jack's answer to this question be no?
>>>
>>>     Jack can't possibly give a correct yes/no answer to the question.
>>>
>>>
>>
>> But you aren't claiming to be solving the Jack Question.
>>
>
>
> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>
>    You ask someone (we'll call him "Jack") to give a truthful
>    yes/no answer to the following question:
>
>    Will Jack's answer to this question be no?
>
>    Jack can't possibly give a correct yes/no answer to the question.
>
> When the halting problem is construed as requiring a correct yes/no
> answer to a self-contradictory question it cannot be solved.

RIght, an

>
> My semantic linguist friends understand that the context of the question
> must include who the question is posed to otherwise the same word-for-
> word question acquires different semantics.

No, it doesn't in this case, because the answer to the question isn't
based on who you ask. Remember, the actual question is does the machine
and input describe halt when run. That question isn't a function of who
you ask.

Do you think the actual answer for the question of who won the last
Presidentlal election in the United States of America depend on you you ask?

>
> The input D to H is the same as Jack's question posed to Jack,
> has no correct answer because within this context the question is
> self-contradictory.

Nope, we can ask that question to ANY halt decider.

The thing you keep forgetting is that H needs to have already been
decided, so its answer to this input has been fixed for all time by the
algorithm coded into H, so we can give a description of this D to any
decider we want.

>
> When we ask someone else what Jack's answer will be or we present a
> different TM with input D the same word-for-word question (or bytes of
> machine description) acquires entirely different semantics and is no
> longer self-contradictory.
>

Except in this case, Jack is a antomiton with a fixed response for every
question, so his answer is determinable. You don't seem to understand
that machines don't have "free-will", but apparently you don't
understand that.

> When we construe the halting problem as determining whether or not an
> (a) Input D will halt on its input <or>
> (b) Either D will not halt or D has a pathological relationship with H

Nope, Not the definition of the Halting Problem, so you are just
admitting you have wasted you life on the wrong problem.

You don't get to change the problem.

>
> Then this halting problem cannot be showed to be unsolvable by any of
> the conventional halting problem proofs.
>

Except it isn't the halting problem any more, so your logic is based on
a false premise.

Remember, the fact that you are incapable of understanding the simple
problem doesn't give you the power to redefine it and still correctly
claim you are working on it.

You have just admitted you are an utter failure.

Richard Damon <Richard@Damon-Family.org> writes:

> Except that the Halting Problem isn't a "Self-Contradictory" Quesiton, so
> the answer doesn't apply.

That's an interesting point that would often catch students out. And
the reason /why/ it catches so many out eventually led me to stop using
the proof-by-contradiction argument in my classes.

The thing is, it looks so very much like a self-contradicting question
is being asked. The students think they can see it right there in the
constructed code: "if H says I halt, I don't halt!".

Of course, they are wrong. The code is /not/ there. The code calls a
function that does not exist, so "it" (the constructed code, the whole
program) does not exist either.

The fact that it's code, and the students are almost all programmers and
not mathematicians, makes it worse. A mathematician seeing "let p be
the largest prime" does not assume that such a p exists. So when a
prime number p' > p is constructed from p, this is not seen as a
"self-contradictory number" because neither p nor p' exist. But the
halting theorem is even more deceptive for programmers, because the
desired function, H (or whatever), appears to be so well defined -- much
more well-defined than "the largest prime". We have an exact
specification for it, mapping arguments to returned values. It's just
software engineering to write such things (they erroneously assume).

These sorts of proof can always be re-worded so as to avoid the initial
assumption. For example, we can start "let p be any prime", and from p
we construct a prime p' > p. And for halting, we can start "let H be
any subroutine of two arguments always returning true or false". Now,
all the objects /do/ exist. In the first case, the construction shows
that no prime is the largest, and in the second it shows that no
subroutine computes the halting function.

This issue led to another change. In the last couple of years, I would
start the course by setting Post's correspondence problem as if it were
just a fun programming challenge. As the days passed (and the course
got into more and more serious material) it would start to become clear
that this was no ordinary programming challenge. Many students started
to suspect that, despite the trivial sounding specification, no program
could do the job. I always felt a bit uneasy doing this, as if I was
not being 100% honest, but it was a very useful learning experience for
most.

--
Ben.

On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> Except that the Halting Problem isn't a "Self-Contradictory" Quesiton, so
>> the answer doesn't apply.
>
> That's an interesting point that would often catch students out. And
> the reason /why/ it catches so many out eventually led me to stop using
> the proof-by-contradiction argument in my classes.
>
> The thing is, it looks so very much like a self-contradicting question
> is being asked. The students think they can see it right there in the
> constructed code: "if H says I halt, I don't halt!".
>
> Of course, they are wrong. The code is /not/ there. The code calls a
> function that does not exist, so "it" (the constructed code, the whole
> program) does not exist either.
>
> The fact that it's code, and the students are almost all programmers and
> not mathematicians, makes it worse. A mathematician seeing "let p be
> the largest prime" does not assume that such a p exists. So when a
> prime number p' > p is constructed from p, this is not seen as a
> "self-contradictory number" because neither p nor p' exist. But the
> halting theorem is even more deceptive for programmers, because the
> desired function, H (or whatever), appears to be so well defined -- much
> more well-defined than "the largest prime". We have an exact
> specification for it, mapping arguments to returned values. It's just
> software engineering to write such things (they erroneously assume).
>
> These sorts of proof can always be re-worded so as to avoid the initial
> assumption. For example, we can start "let p be any prime", and from p
> we construct a prime p' > p. And for halting, we can start "let H be
> any subroutine of two arguments always returning true or false". Now,
> all the objects /do/ exist. In the first case, the construction shows
> that no prime is the largest, and in the second it shows that no
> subroutine computes the halting function.
>
> This issue led to another change. In the last couple of years, I would
> start the course by setting Post's correspondence problem as if it were
> just a fun programming challenge. As the days passed (and the course
> got into more and more serious material) it would start to become clear
> that this was no ordinary programming challenge. Many students started
> to suspect that, despite the trivial sounding specification, no program
> could do the job. I always felt a bit uneasy doing this, as if I was
> not being 100% honest, but it was a very useful learning experience for
> most.
>

sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
You ask someone (we'll call him "Jack") to give a truthful
yes/no answer to the following question:

Will Jack's answer to this question be no?

Jack can't possibly give a correct yes/no answer to the question.

It is an easily verified fact that when Jack's question is posed to Jack
that this question is self-contradictory for Jack or anyone else having
a pathological relationship to the question.

It is also clear that when a question has no yes or no answer because
it is self-contradictory that this question is aptly classified as
incorrect.

It is incorrect to say that a question is not self-contradictory on the
basis that it is not self-contradictory in some contexts. If a question
is self-contradictory in some contexts then in these contexts it is an
incorrect question.

When we clearly understand the truth of this then and only then we have
the means to overcome the enormous inertia of the [received view] of
the conventional wisdom regarding decision problems that are only
undecidable because of pathological relationships.

Because of the brilliant work of Daryl McCullough we can see the actual
reality behind decision problems that are undecidable because of their
pathological relationships.

It only took ChatGPT a few hours and 60 pages of dialogue
to understand and agree with this.
https://www.liarparadox.org/ChatGPT_HP.pdf

ChatGPT:
"Therefore, based on the understanding that self-contradictory
questions lack a correct answer and are deemed incorrect, one could
argue that the halting problem's pathological input D can be
categorized as an incorrect question when posed to the halting
decider H."

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

On 6/17/2023 3:46 PM, olcott wrote:
> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>> Quesiton, so
>>> the answer doesn't apply.
>>
>> That's an interesting point that would often catch students out.  And
>> the reason /why/ it catches so many out eventually led me to stop using
>> the proof-by-contradiction argument in my classes.
>>
>> The thing is, it looks so very much like a self-contradicting question
>> is being asked.  The students think they can see it right there in the
>> constructed code: "if H says I halt, I don't halt!".
>>
>> Of course, they are wrong.  The code is /not/ there.  The code calls a
>> function that does not exist, so "it" (the constructed code, the whole
>> program) does not exist either.
>>
>> The fact that it's code, and the students are almost all programmers and
>> not mathematicians, makes it worse.  A mathematician seeing "let p be
>> the largest prime" does not assume that such a p exists.  So when a
>> prime number p' > p is constructed from p, this is not seen as a
>> "self-contradictory number" because neither p nor p' exist.  But the
>> halting theorem is even more deceptive for programmers, because the
>> desired function, H (or whatever), appears to be so well defined -- much
>> more well-defined than "the largest prime".  We have an exact
>> specification for it, mapping arguments to returned values.  It's just
>> software engineering to write such things (they erroneously assume).
>>
>> These sorts of proof can always be re-worded so as to avoid the initial
>> assumption.  For example, we can start "let p be any prime", and from p
>> we construct a prime p' > p.  And for halting, we can start "let H be
>> any subroutine of two arguments always returning true or false".  Now,
>> all the objects /do/ exist.  In the first case, the construction shows
>> that no prime is the largest, and in the second it shows that no
>> subroutine computes the halting function.
>>
>> This issue led to another change.  In the last couple of years, I would
>> start the course by setting Post's correspondence problem as if it were
>> just a fun programming challenge.  As the days passed (and the course
>> got into more and more serious material) it would start to become clear
>> that this was no ordinary programming challenge.  Many students started
>> to suspect that, despite the trivial sounding specification, no program
>> could do the job.  I always felt a bit uneasy doing this, as if I was
>> not being 100% honest, but it was a very useful learning experience for
>> most.
>>
>
> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>    You ask someone (we'll call him "Jack") to give a truthful
>    yes/no answer to the following question:
>
>    Will Jack's answer to this question be no?
>
>    Jack can't possibly give a correct yes/no answer to the question.
>
> It is an easily verified fact that when Jack's question is posed to Jack
> that this question is self-contradictory for Jack or anyone else having
> a pathological relationship to the question.
>
> It is also clear that when a question has no yes or no answer because
> it is self-contradictory that this question is aptly classified as
> incorrect.
>
> It is incorrect to say that a question is not self-contradictory on the
> basis that it is not self-contradictory in some contexts. If a question
> is self-contradictory in some contexts then in these contexts it is an
> incorrect question.
>
> When we clearly understand the truth of this then and only then we have
> the means to overcome the enormous inertia of the [received view] of
> the conventional wisdom regarding decision problems that are only
> undecidable because of pathological relationships.
>
> Because of the brilliant work of Daryl McCullough we can see the actual
> reality behind decision problems that are undecidable because of their
> pathological relationships.
>
> It only took ChatGPT a few hours and 60 pages of dialogue
> to understand and agree with this.
> https://www.liarparadox.org/ChatGPT_HP.pdf
>
> ChatGPT:
>   "Therefore, based on the understanding that self-contradictory
>    questions lack a correct answer and are deemed incorrect, one could
>    argue that the halting problem's pathological input D can be
>    categorized as an incorrect question when posed to the halting
>    decider H."
Ben was describing an improved approach to teaching some theoretical
results to CS pupils. Those pupils were assumed to have some grounding
in practical aspects such as programming and at least a small interest
and competence in basic mathematics. You seemed to not be there when god
handed out those basic components of a human brain. You are neither the
exception or the rule; just an arrogant dumb fuck.
By the way, we have noticed that you haven't played the big "C" card
recently. Is this 1) an immaculate cure, 2) you putting on your big boy
pants and taking responsibility for your own sorry life and mind, or 3)
the time where you try to wiggle out of a past sequel of lies? We've
seen all but variation 2 in past interactions. The curious want to know
the real skinny so speak up!
--
Jeff Barnett

On 6/17/23 5:46 PM, olcott wrote:
> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>> Richard Damon <Richard@Damon-Family.org> writes:
>>
>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>> Quesiton, so
>>> the answer doesn't apply.
>>
>> That's an interesting point that would often catch students out.  And
>> the reason /why/ it catches so many out eventually led me to stop using
>> the proof-by-contradiction argument in my classes.
>>
>> The thing is, it looks so very much like a self-contradicting question
>> is being asked.  The students think they can see it right there in the
>> constructed code: "if H says I halt, I don't halt!".
>>
>> Of course, they are wrong.  The code is /not/ there.  The code calls a
>> function that does not exist, so "it" (the constructed code, the whole
>> program) does not exist either.
>>
>> The fact that it's code, and the students are almost all programmers and
>> not mathematicians, makes it worse.  A mathematician seeing "let p be
>> the largest prime" does not assume that such a p exists.  So when a
>> prime number p' > p is constructed from p, this is not seen as a
>> "self-contradictory number" because neither p nor p' exist.  But the
>> halting theorem is even more deceptive for programmers, because the
>> desired function, H (or whatever), appears to be so well defined -- much
>> more well-defined than "the largest prime".  We have an exact
>> specification for it, mapping arguments to returned values.  It's just
>> software engineering to write such things (they erroneously assume).
>>
>> These sorts of proof can always be re-worded so as to avoid the initial
>> assumption.  For example, we can start "let p be any prime", and from p
>> we construct a prime p' > p.  And for halting, we can start "let H be
>> any subroutine of two arguments always returning true or false".  Now,
>> all the objects /do/ exist.  In the first case, the construction shows
>> that no prime is the largest, and in the second it shows that no
>> subroutine computes the halting function.
>>
>> This issue led to another change.  In the last couple of years, I would
>> start the course by setting Post's correspondence problem as if it were
>> just a fun programming challenge.  As the days passed (and the course
>> got into more and more serious material) it would start to become clear
>> that this was no ordinary programming challenge.  Many students started
>> to suspect that, despite the trivial sounding specification, no program
>> could do the job.  I always felt a bit uneasy doing this, as if I was
>> not being 100% honest, but it was a very useful learning experience for
>> most.
>>
>
> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>    You ask someone (we'll call him "Jack") to give a truthful
>    yes/no answer to the following question:
>
>    Will Jack's answer to this question be no?
>
>    Jack can't possibly give a correct yes/no answer to the question.
>
> It is an easily verified fact that when Jack's question is posed to Jack
> that this question is self-contradictory for Jack or anyone else having
> a pathological relationship to the question.

But the problem is "Jack" here is assumed to be a volitional being.

H is not, it is a program, so before we even ask H what will happen, the
answer has been fixed by the definition of the codr of H.

>
> It is also clear that when a question has no yes or no answer because
> it is self-contradictory that this question is aptly classified as
> incorrect.

And the actual question DOES have a yes or no answer, in this case,
since H(D,D) says 0 (non-Halting) the actual answer to the question does
D(D) Halt is YES.

You just confuse yourself by trying to imagine a program that can
somehow change itself "at will".

>
> It is incorrect to say that a question is not self-contradictory on the
> basis that it is not self-contradictory in some contexts. If a question
> is self-contradictory in some contexts then in these contexts it is an
> incorrect question.

In what context is "Does the Machine D(D) Halt When run" become
self-contradictory?

Remember, to ask the question, D has to have been defined, which means H
has been defined, so there is no arguing about "if H acted different"
since the specific example can't act different.

>
> When we clearly understand the truth of this then and only then we have
> the means to overcome the enormous inertia of the [received view] of
> the conventional wisdom regarding decision problems that are only
> undecidable because of pathological relationships.

No, you have poisoned your brain to think that reality doesn't actually
matter. You have made yourself an idiot.

H does what it does, and arguing about what would happen if it did
something else is like claiming cats can bark, because if a cat was a
dog, it could do that.

>
> Because of the brilliant work of Daryl McCullough we can see the actual
> reality behind decision problems that are undecidable because of their
> pathological relationships.
>
> It only took ChatGPT a few hours and 60 pages of dialogue
> to understand and agree with this.
> https://www.liarparadox.org/ChatGPT_HP.pdf
>
> ChatGPT:
>   "Therefore, based on the understanding that self-contradictory
>    questions lack a correct answer and are deemed incorrect, one could
>    argue that the halting problem's pathological input D can be
>    categorized as an incorrect question when posed to the halting
>    decider H."
>

And, as pointed out, that isn't the question being ask, so you arguement
just shows you are wrong.

IF you think that a given machine's halting property when it is run
depends on who you ask, shows you are just STUPID.

On 6/17/23 6:03 PM, Jeff Barnett wrote:
>
> By the way, we have noticed that you haven't played the big "C" card
> recently. Is this 1) an immaculate cure, 2) you putting on your big boy
> pants and taking responsibility for your own sorry life and mind, or 3)
> the time where you try to wiggle out of a past sequel of lies? We've
> seen all but variation 2 in past interactions. The curious want to know
> the real skinny so speak up!
> --
> Jeff Barnett

My assumption (but just that) is that it has been a lie the whole time
to try to gain sympathy. He as earned no reputation for honesty, and so
none will be given.

I will admit he might have been sick, but there has been no actual
evidence of it, so it is mearly an unsubstantiated claim.

On 6/17/2023 6:18 PM, Richard Damon wrote:
> On 6/17/23 6:03 PM, Jeff Barnett wrote:
>>
>> By the way, we have noticed that you haven't played the big "C" card
>> recently. Is this 1) an immaculate cure, 2) you putting on your big
>> boy pants and taking responsibility for your own sorry life and mind,
>> or 3) the time where you try to wiggle out of a past sequel of lies?
>> We've seen all but variation 2 in past interactions. The curious want
>> to know the real skinny so speak up!
>> --
>> Jeff Barnett
>
>
> My assumption (but just that) is that it has been a lie the whole time
> to try to gain sympathy. He as earned no reputation for honesty, and so
> none will be given.
>
> I will admit he might have been sick, but there has been no actual
> evidence of it, so it is mearly an unsubstantiated claim.

I did have cancer jam packed in every lymph node.
After chemo therapy last Summer this has cleared up.

It is my current understanding that Follicular Lymphoma always
comes back eventually.

A FLIPI index score of 3 was very bad news.
A 53% five year survival rate and a 35% 10 year survival rate.
https://www.nature.com/articles/s41408-019-0269-6

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

On 6/17/2023 6:13 PM, Richard Damon wrote:
> On 6/17/23 5:46 PM, olcott wrote:
>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>> Quesiton, so
>>>> the answer doesn't apply.
>>>
>>> That's an interesting point that would often catch students out.  And
>>> the reason /why/ it catches so many out eventually led me to stop using
>>> the proof-by-contradiction argument in my classes.
>>>
>>> The thing is, it looks so very much like a self-contradicting question
>>> is being asked.  The students think they can see it right there in the
>>> constructed code: "if H says I halt, I don't halt!".
>>>
>>> Of course, they are wrong.  The code is /not/ there.  The code calls a
>>> function that does not exist, so "it" (the constructed code, the whole
>>> program) does not exist either.
>>>
>>> The fact that it's code, and the students are almost all programmers and
>>> not mathematicians, makes it worse.  A mathematician seeing "let p be
>>> the largest prime" does not assume that such a p exists.  So when a
>>> prime number p' > p is constructed from p, this is not seen as a
>>> "self-contradictory number" because neither p nor p' exist.  But the
>>> halting theorem is even more deceptive for programmers, because the
>>> desired function, H (or whatever), appears to be so well defined -- much
>>> more well-defined than "the largest prime".  We have an exact
>>> specification for it, mapping arguments to returned values.  It's just
>>> software engineering to write such things (they erroneously assume).
>>>
>>> These sorts of proof can always be re-worded so as to avoid the initial
>>> assumption.  For example, we can start "let p be any prime", and from p
>>> we construct a prime p' > p.  And for halting, we can start "let H be
>>> any subroutine of two arguments always returning true or false".  Now,
>>> all the objects /do/ exist.  In the first case, the construction shows
>>> that no prime is the largest, and in the second it shows that no
>>> subroutine computes the halting function.
>>>
>>> This issue led to another change.  In the last couple of years, I would
>>> start the course by setting Post's correspondence problem as if it were
>>> just a fun programming challenge.  As the days passed (and the course
>>> got into more and more serious material) it would start to become clear
>>> that this was no ordinary programming challenge.  Many students started
>>> to suspect that, despite the trivial sounding specification, no program
>>> could do the job.  I always felt a bit uneasy doing this, as if I was
>>> not being 100% honest, but it was a very useful learning experience for
>>> most.
>>>
>>
>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>     You ask someone (we'll call him "Jack") to give a truthful
>>     yes/no answer to the following question:
>>
>>     Will Jack's answer to this question be no?
>>
>>     Jack can't possibly give a correct yes/no answer to the question.
>>
>> It is an easily verified fact that when Jack's question is posed to Jack
>> that this question is self-contradictory for Jack or anyone else having
>> a pathological relationship to the question.
>
> But the problem is "Jack" here is assumed to be a volitional being.
>
> H is not, it is a program, so before we even ask H what will happen, the
> answer has been fixed by the definition of the codr of H.
>
>>
>> It is also clear that when a question has no yes or no answer because
>> it is self-contradictory that this question is aptly classified as
>> incorrect.
>
> And the actual question DOES have a yes or no answer, in this case,
> since H(D,D) says 0 (non-Halting) the actual answer to the question does
> D(D) Halt is YES.
>
> You just confuse yourself by trying to imagine a program that can
> somehow change itself "at will".
>
>>
>> It is incorrect to say that a question is not self-contradictory on the
>> basis that it is not self-contradictory in some contexts. If a question
>> is self-contradictory in some contexts then in these contexts it is an
>> incorrect question.
>
> In what context is "Does the Machine D(D) Halt When run" become
> self-contradictory?
When this question is posed to machine H.

Jack could be asked the question:
Will Jack answer "no" to this question?

For Jack it is self-contradictory for others that are not
Jack it is not self-contradictory. Context changes the semantics.

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

On 6/17/23 7:58 PM, olcott wrote:
> On 6/17/2023 6:13 PM, Richard Damon wrote:
>> On 6/17/23 5:46 PM, olcott wrote:
>>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>>> Quesiton, so
>>>>> the answer doesn't apply.
>>>>
>>>> That's an interesting point that would often catch students out.  And
>>>> the reason /why/ it catches so many out eventually led me to stop using
>>>> the proof-by-contradiction argument in my classes.
>>>>
>>>> The thing is, it looks so very much like a self-contradicting question
>>>> is being asked.  The students think they can see it right there in the
>>>> constructed code: "if H says I halt, I don't halt!".
>>>>
>>>> Of course, they are wrong.  The code is /not/ there.  The code calls a
>>>> function that does not exist, so "it" (the constructed code, the whole
>>>> program) does not exist either.
>>>>
>>>> The fact that it's code, and the students are almost all programmers
>>>> and
>>>> not mathematicians, makes it worse.  A mathematician seeing "let p be
>>>> the largest prime" does not assume that such a p exists.  So when a
>>>> prime number p' > p is constructed from p, this is not seen as a
>>>> "self-contradictory number" because neither p nor p' exist.  But the
>>>> halting theorem is even more deceptive for programmers, because the
>>>> desired function, H (or whatever), appears to be so well defined --
>>>> much
>>>> more well-defined than "the largest prime".  We have an exact
>>>> specification for it, mapping arguments to returned values.  It's just
>>>> software engineering to write such things (they erroneously assume).
>>>>
>>>> These sorts of proof can always be re-worded so as to avoid the initial
>>>> assumption.  For example, we can start "let p be any prime", and from p
>>>> we construct a prime p' > p.  And for halting, we can start "let H be
>>>> any subroutine of two arguments always returning true or false".  Now,
>>>> all the objects /do/ exist.  In the first case, the construction shows
>>>> that no prime is the largest, and in the second it shows that no
>>>> subroutine computes the halting function.
>>>>
>>>> This issue led to another change.  In the last couple of years, I would
>>>> start the course by setting Post's correspondence problem as if it were
>>>> just a fun programming challenge.  As the days passed (and the course
>>>> got into more and more serious material) it would start to become clear
>>>> that this was no ordinary programming challenge.  Many students started
>>>> to suspect that, despite the trivial sounding specification, no program
>>>> could do the job.  I always felt a bit uneasy doing this, as if I was
>>>> not being 100% honest, but it was a very useful learning experience for
>>>> most.
>>>>
>>>
>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>     yes/no answer to the following question:
>>>
>>>     Will Jack's answer to this question be no?
>>>
>>>     Jack can't possibly give a correct yes/no answer to the question.
>>>
>>> It is an easily verified fact that when Jack's question is posed to Jack
>>> that this question is self-contradictory for Jack or anyone else having
>>> a pathological relationship to the question.
>>
>> But the problem is "Jack" here is assumed to be a volitional being.
>>
>> H is not, it is a program, so before we even ask H what will happen,
>> the answer has been fixed by the definition of the codr of H.
>>
>>>
>>> It is also clear that when a question has no yes or no answer because
>>> it is self-contradictory that this question is aptly classified as
>>> incorrect.
>>
>> And the actual question DOES have a yes or no answer, in this case,
>> since H(D,D) says 0 (non-Halting) the actual answer to the question
>> does D(D) Halt is YES.
>>
>> You just confuse yourself by trying to imagine a program that can
>> somehow change itself "at will".
>>
>>>
>>> It is incorrect to say that a question is not self-contradictory on the
>>> basis that it is not self-contradictory in some contexts. If a question
>>> is self-contradictory in some contexts then in these contexts it is an
>>> incorrect question.
>>
>> In what context is "Does the Machine D(D) Halt When run" become
>> self-contradictory?
> When this question is posed to machine H.
>
> Jack could be asked the question:
> Will Jack answer "no" to this question?
>
> For Jack it is self-contradictory for others that are not
> Jack it is not self-contradictory. Context changes the semantics.
>

But you are missing the difference. A Decider is a fixed piece of code,
so its answer has always been fixed to this question since it has been
designed. Thus what it will say isn't a varialbe that can lead to the
self-contradiction cycle, but a fixed result that will either be correct
or incorrect.

A given H can't help but give the answer its program says it will give.
and thus it doesn't matter that we are asking H itself, as its answer is
already fixed.

You are confusing logic about volitional beings with logic about fixed
procedures.

Add in that if you actually did it right, and the input had a new copy
of a program equivalent to H, then your method used by H to detect the
"pathological" interaction become impossible. (This is why you need to
precisely define what you mean by "pathological relationship", you will
find that either you H can't detect it or we can make a variation on H
that D can use that doesn't meet your defintion of pathological but
still makes H wrong.

On 6/17/23 7:44 PM, olcott wrote:
> On 6/17/2023 6:18 PM, Richard Damon wrote:
>> On 6/17/23 6:03 PM, Jeff Barnett wrote:
>>>
>>> By the way, we have noticed that you haven't played the big "C" card
>>> recently. Is this 1) an immaculate cure, 2) you putting on your big
>>> boy pants and taking responsibility for your own sorry life and mind,
>>> or 3) the time where you try to wiggle out of a past sequel of lies?
>>> We've seen all but variation 2 in past interactions. The curious want
>>> to know the real skinny so speak up!
>>> --
>>> Jeff Barnett
>>
>>
>> My assumption (but just that) is that it has been a lie the whole time
>> to try to gain sympathy. He as earned no reputation for honesty, and
>> so none will be given.
>>
>> I will admit he might have been sick, but there has been no actual
>> evidence of it, so it is mearly an unsubstantiated claim.
>
> I did have cancer jam packed in every lymph node.
> After chemo therapy last Summer this has cleared up.
>
> It is my current understanding that Follicular Lymphoma always
> comes back eventually.
>
> A FLIPI index score of 3 was very bad news.
> A 53% five year survival rate and a 35% 10 year survival rate.
> https://www.nature.com/articles/s41408-019-0269-6
>

Which is a fairly amazing recovery, as your reports from a year and a
half ago were something like 90% dead by the end of last year from my
memory.

I won't say you are lying, as I have no evidence, and do admit you could
be telling the truth, but considering your verasity at other topics, you
have no credit earned in believability, and shading some of the truth is
an act I wouldn't put past you.

On 6/17/2023 8:31 PM, Richard Damon wrote:
> On 6/17/23 7:58 PM, olcott wrote:
>> On 6/17/2023 6:13 PM, Richard Damon wrote:
>>> On 6/17/23 5:46 PM, olcott wrote:
>>>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>>>> Quesiton, so
>>>>>> the answer doesn't apply.
>>>>>
>>>>> That's an interesting point that would often catch students out.  And
>>>>> the reason /why/ it catches so many out eventually led me to stop
>>>>> using
>>>>> the proof-by-contradiction argument in my classes.
>>>>>
>>>>> The thing is, it looks so very much like a self-contradicting question
>>>>> is being asked.  The students think they can see it right there in the
>>>>> constructed code: "if H says I halt, I don't halt!".
>>>>>
>>>>> Of course, they are wrong.  The code is /not/ there.  The code calls a
>>>>> function that does not exist, so "it" (the constructed code, the whole
>>>>> program) does not exist either.
>>>>>
>>>>> The fact that it's code, and the students are almost all
>>>>> programmers and
>>>>> not mathematicians, makes it worse.  A mathematician seeing "let p be
>>>>> the largest prime" does not assume that such a p exists.  So when a
>>>>> prime number p' > p is constructed from p, this is not seen as a
>>>>> "self-contradictory number" because neither p nor p' exist.  But the
>>>>> halting theorem is even more deceptive for programmers, because the
>>>>> desired function, H (or whatever), appears to be so well defined --
>>>>> much
>>>>> more well-defined than "the largest prime".  We have an exact
>>>>> specification for it, mapping arguments to returned values.  It's just
>>>>> software engineering to write such things (they erroneously assume).
>>>>>
>>>>> These sorts of proof can always be re-worded so as to avoid the
>>>>> initial
>>>>> assumption.  For example, we can start "let p be any prime", and
>>>>> from p
>>>>> we construct a prime p' > p.  And for halting, we can start "let H be
>>>>> any subroutine of two arguments always returning true or false".  Now,
>>>>> all the objects /do/ exist.  In the first case, the construction shows
>>>>> that no prime is the largest, and in the second it shows that no
>>>>> subroutine computes the halting function.
>>>>>
>>>>> This issue led to another change.  In the last couple of years, I
>>>>> would
>>>>> start the course by setting Post's correspondence problem as if it
>>>>> were
>>>>> just a fun programming challenge.  As the days passed (and the course
>>>>> got into more and more serious material) it would start to become
>>>>> clear
>>>>> that this was no ordinary programming challenge.  Many students
>>>>> started
>>>>> to suspect that, despite the trivial sounding specification, no
>>>>> program
>>>>> could do the job.  I always felt a bit uneasy doing this, as if I was
>>>>> not being 100% honest, but it was a very useful learning experience
>>>>> for
>>>>> most.
>>>>>
>>>>
>>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>>     yes/no answer to the following question:
>>>>
>>>>     Will Jack's answer to this question be no?
>>>>
>>>>     Jack can't possibly give a correct yes/no answer to the question.
>>>>
>>>> It is an easily verified fact that when Jack's question is posed to
>>>> Jack
>>>> that this question is self-contradictory for Jack or anyone else having
>>>> a pathological relationship to the question.
>>>
>>> But the problem is "Jack" here is assumed to be a volitional being.
>>>
>>> H is not, it is a program, so before we even ask H what will happen,
>>> the answer has been fixed by the definition of the codr of H.
>>>
>>>>
>>>> It is also clear that when a question has no yes or no answer because
>>>> it is self-contradictory that this question is aptly classified as
>>>> incorrect.
>>>
>>> And the actual question DOES have a yes or no answer, in this case,
>>> since H(D,D) says 0 (non-Halting) the actual answer to the question
>>> does D(D) Halt is YES.
>>>
>>> You just confuse yourself by trying to imagine a program that can
>>> somehow change itself "at will".
>>>
>>>>
>>>> It is incorrect to say that a question is not self-contradictory on the
>>>> basis that it is not self-contradictory in some contexts. If a question
>>>> is self-contradictory in some contexts then in these contexts it is an
>>>> incorrect question.
>>>
>>> In what context is "Does the Machine D(D) Halt When run" become
>>> self-contradictory?
>> When this question is posed to machine H.
>>
>> Jack could be asked the question:
>> Will Jack answer "no" to this question?
>>
>> For Jack it is self-contradictory for others that are not
>> Jack it is not self-contradictory. Context changes the semantics.
>>
>
> But you are missing the difference. A Decider is a fixed piece of code,
> so its answer has always been fixed to this question since it has been
> designed. Thus what it will say isn't a varialbe that can lead to the
> self-contradiction cycle, but a fixed result that will either be correct
> or incorrect.
>

Every input to a Turing machine decider such that both Boolean return
values are incorrect is an incorrect input.

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

On 6/17/2023 8:46 PM, Richard Damon wrote:
> On 6/17/23 7:44 PM, olcott wrote:
>> On 6/17/2023 6:18 PM, Richard Damon wrote:
>>> On 6/17/23 6:03 PM, Jeff Barnett wrote:
>>>>
>>>> By the way, we have noticed that you haven't played the big "C" card
>>>> recently. Is this 1) an immaculate cure, 2) you putting on your big
>>>> boy pants and taking responsibility for your own sorry life and
>>>> mind, or 3) the time where you try to wiggle out of a past sequel of
>>>> lies? We've seen all but variation 2 in past interactions. The
>>>> curious want to know the real skinny so speak up!
>>>> --
>>>> Jeff Barnett
>>>
>>>
>>> My assumption (but just that) is that it has been a lie the whole
>>> time to try to gain sympathy. He as earned no reputation for honesty,
>>> and so none will be given.
>>>
>>> I will admit he might have been sick, but there has been no actual
>>> evidence of it, so it is mearly an unsubstantiated claim.
>>
>> I did have cancer jam packed in every lymph node.
>> After chemo therapy last Summer this has cleared up.
>>
>> It is my current understanding that Follicular Lymphoma always
>> comes back eventually.
>>
>> A FLIPI index score of 3 was very bad news.
>> A 53% five year survival rate and a 35% 10 year survival rate.
>> https://www.nature.com/articles/s41408-019-0269-6
>>
>
> Which is a fairly amazing recovery, as your reports from a year and a
> half ago were something like 90% dead by the end of last year from my
> memory.
>
> I won't say you are lying, as I have no evidence, and do admit you could
> be telling the truth, but considering your verasity at other topics, you
> have no credit earned in believability, and shading some of the truth is
> an act I wouldn't put past you.
>

It is not the case that I ever lied on this forum. Most people
make the mistake of calling me a liar entirely on the basis that
they really really don't believe me and what I say goes against
conventional wisdom.

Most people seem to take conventional wisdom as the infallible
word of God.

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

On 6/17/23 10:29 PM, olcott wrote:
> On 6/17/2023 8:31 PM, Richard Damon wrote:
>> On 6/17/23 7:58 PM, olcott wrote:
>>> On 6/17/2023 6:13 PM, Richard Damon wrote:
>>>> On 6/17/23 5:46 PM, olcott wrote:
>>>>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>
>>>>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>>>>> Quesiton, so
>>>>>>> the answer doesn't apply.
>>>>>>
>>>>>> That's an interesting point that would often catch students out.  And
>>>>>> the reason /why/ it catches so many out eventually led me to stop
>>>>>> using
>>>>>> the proof-by-contradiction argument in my classes.
>>>>>>
>>>>>> The thing is, it looks so very much like a self-contradicting
>>>>>> question
>>>>>> is being asked.  The students think they can see it right there in
>>>>>> the
>>>>>> constructed code: "if H says I halt, I don't halt!".
>>>>>>
>>>>>> Of course, they are wrong.  The code is /not/ there.  The code
>>>>>> calls a
>>>>>> function that does not exist, so "it" (the constructed code, the
>>>>>> whole
>>>>>> program) does not exist either.
>>>>>>
>>>>>> The fact that it's code, and the students are almost all
>>>>>> programmers and
>>>>>> not mathematicians, makes it worse.  A mathematician seeing "let p be
>>>>>> the largest prime" does not assume that such a p exists.  So when a
>>>>>> prime number p' > p is constructed from p, this is not seen as a
>>>>>> "self-contradictory number" because neither p nor p' exist.  But the
>>>>>> halting theorem is even more deceptive for programmers, because the
>>>>>> desired function, H (or whatever), appears to be so well defined
>>>>>> -- much
>>>>>> more well-defined than "the largest prime".  We have an exact
>>>>>> specification for it, mapping arguments to returned values.  It's
>>>>>> just
>>>>>> software engineering to write such things (they erroneously assume).
>>>>>>
>>>>>> These sorts of proof can always be re-worded so as to avoid the
>>>>>> initial
>>>>>> assumption.  For example, we can start "let p be any prime", and
>>>>>> from p
>>>>>> we construct a prime p' > p.  And for halting, we can start "let H be
>>>>>> any subroutine of two arguments always returning true or false".
>>>>>> Now,
>>>>>> all the objects /do/ exist.  In the first case, the construction
>>>>>> shows
>>>>>> that no prime is the largest, and in the second it shows that no
>>>>>> subroutine computes the halting function.
>>>>>>
>>>>>> This issue led to another change.  In the last couple of years, I
>>>>>> would
>>>>>> start the course by setting Post's correspondence problem as if it
>>>>>> were
>>>>>> just a fun programming challenge.  As the days passed (and the course
>>>>>> got into more and more serious material) it would start to become
>>>>>> clear
>>>>>> that this was no ordinary programming challenge.  Many students
>>>>>> started
>>>>>> to suspect that, despite the trivial sounding specification, no
>>>>>> program
>>>>>> could do the job.  I always felt a bit uneasy doing this, as if I was
>>>>>> not being 100% honest, but it was a very useful learning
>>>>>> experience for
>>>>>> most.
>>>>>>
>>>>>
>>>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>>>     yes/no answer to the following question:
>>>>>
>>>>>     Will Jack's answer to this question be no?
>>>>>
>>>>>     Jack can't possibly give a correct yes/no answer to the question.
>>>>>
>>>>> It is an easily verified fact that when Jack's question is posed to
>>>>> Jack
>>>>> that this question is self-contradictory for Jack or anyone else
>>>>> having
>>>>> a pathological relationship to the question.
>>>>
>>>> But the problem is "Jack" here is assumed to be a volitional being.
>>>>
>>>> H is not, it is a program, so before we even ask H what will happen,
>>>> the answer has been fixed by the definition of the codr of H.
>>>>
>>>>>
>>>>> It is also clear that when a question has no yes or no answer because
>>>>> it is self-contradictory that this question is aptly classified as
>>>>> incorrect.
>>>>
>>>> And the actual question DOES have a yes or no answer, in this case,
>>>> since H(D,D) says 0 (non-Halting) the actual answer to the question
>>>> does D(D) Halt is YES.
>>>>
>>>> You just confuse yourself by trying to imagine a program that can
>>>> somehow change itself "at will".
>>>>
>>>>>
>>>>> It is incorrect to say that a question is not self-contradictory on
>>>>> the
>>>>> basis that it is not self-contradictory in some contexts. If a
>>>>> question
>>>>> is self-contradictory in some contexts then in these contexts it is an
>>>>> incorrect question.
>>>>
>>>> In what context is "Does the Machine D(D) Halt When run" become
>>>> self-contradictory?
>>> When this question is posed to machine H.
>>>
>>> Jack could be asked the question:
>>> Will Jack answer "no" to this question?
>>>
>>> For Jack it is self-contradictory for others that are not
>>> Jack it is not self-contradictory. Context changes the semantics.
>>>
>>
>> But you are missing the difference. A Decider is a fixed piece of
>> code, so its answer has always been fixed to this question since it
>> has been designed. Thus what it will say isn't a varialbe that can
>> lead to the self-contradiction cycle, but a fixed result that will
>> either be correct or incorrect.
>>
>
> Every input to a Turing machine decider such that both Boolean return
> values are incorrect is an incorrect input.
>

Except it isn't. The problem is you are looking at two different
machines and two different inputs.

If you define your H0 to return 0 when given the input <D0> <D0> for the
D0 built on D0, then since D0 applied to <D0> will halt so the correct
answer is 1. If H0 returned that answer, it would have been correct, but
since H0 was defined with code that answered 0, that is the only thing
that it can answer.

On the other hand, if you instead defined a DIFFERENT machine H1, that
uses similar logic, but instead of returning Non-Halting, returned
Halting, the H1 applied to <D0> <D0> would abort its simulation and
return 1, and it would have been correct. The problem here is that since
H1 is a different machine, its "pathological" program is different,
(since it will be built on H1, not H0) and H1 applied to <D1> <D1> will
abort its simulation and return 1, but D1 applied to <D1> will go into
an infinite loop, so the correct answer should have been 0.

So, the problem is that the two cases you are looking at are DIFF#RENT
inputs, because they are built on DIFFERENT machines. You don't seem to
understand that a machine WILL generate the results that machine is
programmed for, so "hypothetical" about it doing somethng different are
just looking at impossible actions.

So, it isn't the case that both answers are wrong for the same question,
it is that the question changes when you alter your decider and whatever
answer you make you decider give, will be wrong, and the other one right.

On 6/17/23 10:35 PM, olcott wrote:
> On 6/17/2023 8:46 PM, Richard Damon wrote:
>> On 6/17/23 7:44 PM, olcott wrote:
>>> On 6/17/2023 6:18 PM, Richard Damon wrote:
>>>> On 6/17/23 6:03 PM, Jeff Barnett wrote:
>>>>>
>>>>> By the way, we have noticed that you haven't played the big "C"
>>>>> card recently. Is this 1) an immaculate cure, 2) you putting on
>>>>> your big boy pants and taking responsibility for your own sorry
>>>>> life and mind, or 3) the time where you try to wiggle out of a past
>>>>> sequel of lies? We've seen all but variation 2 in past
>>>>> interactions. The curious want to know the real skinny so speak up!
>>>>> --
>>>>> Jeff Barnett
>>>>
>>>>
>>>> My assumption (but just that) is that it has been a lie the whole
>>>> time to try to gain sympathy. He as earned no reputation for
>>>> honesty, and so none will be given.
>>>>
>>>> I will admit he might have been sick, but there has been no actual
>>>> evidence of it, so it is mearly an unsubstantiated claim.
>>>
>>> I did have cancer jam packed in every lymph node.
>>> After chemo therapy last Summer this has cleared up.
>>>
>>> It is my current understanding that Follicular Lymphoma always
>>> comes back eventually.
>>>
>>> A FLIPI index score of 3 was very bad news.
>>> A 53% five year survival rate and a 35% 10 year survival rate.
>>> https://www.nature.com/articles/s41408-019-0269-6
>>>
>>
>> Which is a fairly amazing recovery, as your reports from a year and a
>> half ago were something like 90% dead by the end of last year from my
>> memory.
>>
>> I won't say you are lying, as I have no evidence, and do admit you
>> could be telling the truth, but considering your verasity at other
>> topics, you have no credit earned in believability, and shading some
>> of the truth is an act I wouldn't put past you.
>>
>
> It is not the case that I ever lied on this forum. Most people
> make the mistake of calling me a liar entirely on the basis that
> they really really don't believe me and what I say goes against
> conventional wisdom.

That is not true. There have been several cases where you have said that
someone said something that just wasn't true.

You also twist the words of people claiming they gave your ideas
support, when they did no such thing.

You also engage in great deception by improper trimming of quotations,
removing "inconvient" (to you) parts of statements to change the meaning
of them.

>
> Most people seem to take conventional wisdom as the infallible
> word of God.
>
>

While you think your own words are that infallible word of God, as you
think you are him.

You don't understand the difference between "conventional Wisdom" and
the DEFINITION of what something is, in part, because you just don't
understand what Truth actually is.

You seem incapable of actually dealing with truth, which is why you are
a pathological liar. I don't think your mind can actually handle how
truth actually works.

On 6/17/2023 9:57 PM, Richard Damon wrote:
> On 6/17/23 10:29 PM, olcott wrote:
>> On 6/17/2023 8:31 PM, Richard Damon wrote:
>>> On 6/17/23 7:58 PM, olcott wrote:
>>>> On 6/17/2023 6:13 PM, Richard Damon wrote:
>>>>> On 6/17/23 5:46 PM, olcott wrote:
>>>>>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>
>>>>>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>>>>>> Quesiton, so
>>>>>>>> the answer doesn't apply.
>>>>>>>
>>>>>>> That's an interesting point that would often catch students out.
>>>>>>> And
>>>>>>> the reason /why/ it catches so many out eventually led me to stop
>>>>>>> using
>>>>>>> the proof-by-contradiction argument in my classes.
>>>>>>>
>>>>>>> The thing is, it looks so very much like a self-contradicting
>>>>>>> question
>>>>>>> is being asked.  The students think they can see it right there
>>>>>>> in the
>>>>>>> constructed code: "if H says I halt, I don't halt!".
>>>>>>>
>>>>>>> Of course, they are wrong.  The code is /not/ there.  The code
>>>>>>> calls a
>>>>>>> function that does not exist, so "it" (the constructed code, the
>>>>>>> whole
>>>>>>> program) does not exist either.
>>>>>>>
>>>>>>> The fact that it's code, and the students are almost all
>>>>>>> programmers and
>>>>>>> not mathematicians, makes it worse.  A mathematician seeing "let
>>>>>>> p be
>>>>>>> the largest prime" does not assume that such a p exists.  So when a
>>>>>>> prime number p' > p is constructed from p, this is not seen as a
>>>>>>> "self-contradictory number" because neither p nor p' exist.  But the
>>>>>>> halting theorem is even more deceptive for programmers, because the
>>>>>>> desired function, H (or whatever), appears to be so well defined
>>>>>>> -- much
>>>>>>> more well-defined than "the largest prime".  We have an exact
>>>>>>> specification for it, mapping arguments to returned values.  It's
>>>>>>> just
>>>>>>> software engineering to write such things (they erroneously assume).
>>>>>>>
>>>>>>> These sorts of proof can always be re-worded so as to avoid the
>>>>>>> initial
>>>>>>> assumption.  For example, we can start "let p be any prime", and
>>>>>>> from p
>>>>>>> we construct a prime p' > p.  And for halting, we can start "let
>>>>>>> H be
>>>>>>> any subroutine of two arguments always returning true or false".
>>>>>>> Now,
>>>>>>> all the objects /do/ exist.  In the first case, the construction
>>>>>>> shows
>>>>>>> that no prime is the largest, and in the second it shows that no
>>>>>>> subroutine computes the halting function.
>>>>>>>
>>>>>>> This issue led to another change.  In the last couple of years, I
>>>>>>> would
>>>>>>> start the course by setting Post's correspondence problem as if
>>>>>>> it were
>>>>>>> just a fun programming challenge.  As the days passed (and the
>>>>>>> course
>>>>>>> got into more and more serious material) it would start to become
>>>>>>> clear
>>>>>>> that this was no ordinary programming challenge.  Many students
>>>>>>> started
>>>>>>> to suspect that, despite the trivial sounding specification, no
>>>>>>> program
>>>>>>> could do the job.  I always felt a bit uneasy doing this, as if I
>>>>>>> was
>>>>>>> not being 100% honest, but it was a very useful learning
>>>>>>> experience for
>>>>>>> most.
>>>>>>>
>>>>>>
>>>>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>>>>     yes/no answer to the following question:
>>>>>>
>>>>>>     Will Jack's answer to this question be no?
>>>>>>
>>>>>>     Jack can't possibly give a correct yes/no answer to the question.
>>>>>>
>>>>>> It is an easily verified fact that when Jack's question is posed
>>>>>> to Jack
>>>>>> that this question is self-contradictory for Jack or anyone else
>>>>>> having
>>>>>> a pathological relationship to the question.
>>>>>
>>>>> But the problem is "Jack" here is assumed to be a volitional being.
>>>>>
>>>>> H is not, it is a program, so before we even ask H what will
>>>>> happen, the answer has been fixed by the definition of the codr of H.
>>>>>
>>>>>>
>>>>>> It is also clear that when a question has no yes or no answer because
>>>>>> it is self-contradictory that this question is aptly classified as
>>>>>> incorrect.
>>>>>
>>>>> And the actual question DOES have a yes or no answer, in this case,
>>>>> since H(D,D) says 0 (non-Halting) the actual answer to the question
>>>>> does D(D) Halt is YES.
>>>>>
>>>>> You just confuse yourself by trying to imagine a program that can
>>>>> somehow change itself "at will".
>>>>>
>>>>>>
>>>>>> It is incorrect to say that a question is not self-contradictory
>>>>>> on the
>>>>>> basis that it is not self-contradictory in some contexts. If a
>>>>>> question
>>>>>> is self-contradictory in some contexts then in these contexts it
>>>>>> is an
>>>>>> incorrect question.
>>>>>
>>>>> In what context is "Does the Machine D(D) Halt When run" become
>>>>> self-contradictory?
>>>> When this question is posed to machine H.
>>>>
>>>> Jack could be asked the question:
>>>> Will Jack answer "no" to this question?
>>>>
>>>> For Jack it is self-contradictory for others that are not
>>>> Jack it is not self-contradictory. Context changes the semantics.
>>>>
>>>
>>> But you are missing the difference. A Decider is a fixed piece of
>>> code, so its answer has always been fixed to this question since it
>>> has been designed. Thus what it will say isn't a varialbe that can
>>> lead to the self-contradiction cycle, but a fixed result that will
>>> either be correct or incorrect.
>>>
>>
>> Every input to a Turing machine decider such that both Boolean return
>> values are incorrect is an incorrect input.
>>
>
> Except it isn't. The problem is you are looking at two different
> machines and two different inputs.
>
If no one can possibly correctly answer what the correct return value
that any H<n> having a pathological relationship to its input D<n> could
possibly provide then that is proof that D<n> is an invalid input for
H<n> in the same way that any self-contradictory question is an
incorrect question.

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

On 6/17/23 11:10 PM, olcott wrote:
> On 6/17/2023 9:57 PM, Richard Damon wrote:
>> On 6/17/23 10:29 PM, olcott wrote:
>>> On 6/17/2023 8:31 PM, Richard Damon wrote:
>>>> On 6/17/23 7:58 PM, olcott wrote:
>>>>> On 6/17/2023 6:13 PM, Richard Damon wrote:
>>>>>> On 6/17/23 5:46 PM, olcott wrote:
>>>>>>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>
>>>>>>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>>>>>>> Quesiton, so
>>>>>>>>> the answer doesn't apply.
>>>>>>>>
>>>>>>>> That's an interesting point that would often catch students out.
>>>>>>>> And
>>>>>>>> the reason /why/ it catches so many out eventually led me to
>>>>>>>> stop using
>>>>>>>> the proof-by-contradiction argument in my classes.
>>>>>>>>
>>>>>>>> The thing is, it looks so very much like a self-contradicting
>>>>>>>> question
>>>>>>>> is being asked.  The students think they can see it right there
>>>>>>>> in the
>>>>>>>> constructed code: "if H says I halt, I don't halt!".
>>>>>>>>
>>>>>>>> Of course, they are wrong.  The code is /not/ there.  The code
>>>>>>>> calls a
>>>>>>>> function that does not exist, so "it" (the constructed code, the
>>>>>>>> whole
>>>>>>>> program) does not exist either.
>>>>>>>>
>>>>>>>> The fact that it's code, and the students are almost all
>>>>>>>> programmers and
>>>>>>>> not mathematicians, makes it worse.  A mathematician seeing "let
>>>>>>>> p be
>>>>>>>> the largest prime" does not assume that such a p exists.  So when a
>>>>>>>> prime number p' > p is constructed from p, this is not seen as a
>>>>>>>> "self-contradictory number" because neither p nor p' exist.  But
>>>>>>>> the
>>>>>>>> halting theorem is even more deceptive for programmers, because the
>>>>>>>> desired function, H (or whatever), appears to be so well defined
>>>>>>>> -- much
>>>>>>>> more well-defined than "the largest prime".  We have an exact
>>>>>>>> specification for it, mapping arguments to returned values.
>>>>>>>> It's just
>>>>>>>> software engineering to write such things (they erroneously
>>>>>>>> assume).
>>>>>>>>
>>>>>>>> These sorts of proof can always be re-worded so as to avoid the
>>>>>>>> initial
>>>>>>>> assumption.  For example, we can start "let p be any prime", and
>>>>>>>> from p
>>>>>>>> we construct a prime p' > p.  And for halting, we can start "let
>>>>>>>> H be
>>>>>>>> any subroutine of two arguments always returning true or false".
>>>>>>>> Now,
>>>>>>>> all the objects /do/ exist.  In the first case, the construction
>>>>>>>> shows
>>>>>>>> that no prime is the largest, and in the second it shows that no
>>>>>>>> subroutine computes the halting function.
>>>>>>>>
>>>>>>>> This issue led to another change.  In the last couple of years,
>>>>>>>> I would
>>>>>>>> start the course by setting Post's correspondence problem as if
>>>>>>>> it were
>>>>>>>> just a fun programming challenge.  As the days passed (and the
>>>>>>>> course
>>>>>>>> got into more and more serious material) it would start to
>>>>>>>> become clear
>>>>>>>> that this was no ordinary programming challenge.  Many students
>>>>>>>> started
>>>>>>>> to suspect that, despite the trivial sounding specification, no
>>>>>>>> program
>>>>>>>> could do the job.  I always felt a bit uneasy doing this, as if
>>>>>>>> I was
>>>>>>>> not being 100% honest, but it was a very useful learning
>>>>>>>> experience for
>>>>>>>> most.
>>>>>>>>
>>>>>>>
>>>>>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>>>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>>>>>     yes/no answer to the following question:
>>>>>>>
>>>>>>>     Will Jack's answer to this question be no?
>>>>>>>
>>>>>>>     Jack can't possibly give a correct yes/no answer to the
>>>>>>> question.
>>>>>>>
>>>>>>> It is an easily verified fact that when Jack's question is posed
>>>>>>> to Jack
>>>>>>> that this question is self-contradictory for Jack or anyone else
>>>>>>> having
>>>>>>> a pathological relationship to the question.
>>>>>>
>>>>>> But the problem is "Jack" here is assumed to be a volitional being.
>>>>>>
>>>>>> H is not, it is a program, so before we even ask H what will
>>>>>> happen, the answer has been fixed by the definition of the codr of H.
>>>>>>
>>>>>>>
>>>>>>> It is also clear that when a question has no yes or no answer
>>>>>>> because
>>>>>>> it is self-contradictory that this question is aptly classified as
>>>>>>> incorrect.
>>>>>>
>>>>>> And the actual question DOES have a yes or no answer, in this
>>>>>> case, since H(D,D) says 0 (non-Halting) the actual answer to the
>>>>>> question does D(D) Halt is YES.
>>>>>>
>>>>>> You just confuse yourself by trying to imagine a program that can
>>>>>> somehow change itself "at will".
>>>>>>
>>>>>>>
>>>>>>> It is incorrect to say that a question is not self-contradictory
>>>>>>> on the
>>>>>>> basis that it is not self-contradictory in some contexts. If a
>>>>>>> question
>>>>>>> is self-contradictory in some contexts then in these contexts it
>>>>>>> is an
>>>>>>> incorrect question.
>>>>>>
>>>>>> In what context is "Does the Machine D(D) Halt When run" become
>>>>>> self-contradictory?
>>>>> When this question is posed to machine H.
>>>>>
>>>>> Jack could be asked the question:
>>>>> Will Jack answer "no" to this question?
>>>>>
>>>>> For Jack it is self-contradictory for others that are not
>>>>> Jack it is not self-contradictory. Context changes the semantics.
>>>>>
>>>>
>>>> But you are missing the difference. A Decider is a fixed piece of
>>>> code, so its answer has always been fixed to this question since it
>>>> has been designed. Thus what it will say isn't a varialbe that can
>>>> lead to the self-contradiction cycle, but a fixed result that will
>>>> either be correct or incorrect.
>>>>
>>>
>>> Every input to a Turing machine decider such that both Boolean return
>>> values are incorrect is an incorrect input.
>>>
>>
>> Except it isn't. The problem is you are looking at two different
>> machines and two different inputs.
>>
> If no one can possibly correctly answer what the correct return value
> that any H<n> having a pathological relationship to its input D<n> could
> possibly provide then that is proof that D<n> is an invalid input for
> H<n> in the same way that any self-contradictory question is an
> incorrect question.
>

On 6/18/2023 7:02 AM, Richard Damon wrote:
> On 6/17/23 11:10 PM, olcott wrote:
>> On 6/17/2023 9:57 PM, Richard Damon wrote:
>>> On 6/17/23 10:29 PM, olcott wrote:
>>>> On 6/17/2023 8:31 PM, Richard Damon wrote:
>>>>> On 6/17/23 7:58 PM, olcott wrote:
>>>>>> On 6/17/2023 6:13 PM, Richard Damon wrote:
>>>>>>> On 6/17/23 5:46 PM, olcott wrote:
>>>>>>>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>
>>>>>>>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>>>>>>>> Quesiton, so
>>>>>>>>>> the answer doesn't apply.
>>>>>>>>>
>>>>>>>>> That's an interesting point that would often catch students
>>>>>>>>> out. And
>>>>>>>>> the reason /why/ it catches so many out eventually led me to
>>>>>>>>> stop using
>>>>>>>>> the proof-by-contradiction argument in my classes.
>>>>>>>>>
>>>>>>>>> The thing is, it looks so very much like a self-contradicting
>>>>>>>>> question
>>>>>>>>> is being asked.  The students think they can see it right there
>>>>>>>>> in the
>>>>>>>>> constructed code: "if H says I halt, I don't halt!".
>>>>>>>>>
>>>>>>>>> Of course, they are wrong.  The code is /not/ there.  The code
>>>>>>>>> calls a
>>>>>>>>> function that does not exist, so "it" (the constructed code,
>>>>>>>>> the whole
>>>>>>>>> program) does not exist either.
>>>>>>>>>
>>>>>>>>> The fact that it's code, and the students are almost all
>>>>>>>>> programmers and
>>>>>>>>> not mathematicians, makes it worse.  A mathematician seeing
>>>>>>>>> "let p be
>>>>>>>>> the largest prime" does not assume that such a p exists.  So
>>>>>>>>> when a
>>>>>>>>> prime number p' > p is constructed from p, this is not seen as a
>>>>>>>>> "self-contradictory number" because neither p nor p' exist.
>>>>>>>>> But the
>>>>>>>>> halting theorem is even more deceptive for programmers, because
>>>>>>>>> the
>>>>>>>>> desired function, H (or whatever), appears to be so well
>>>>>>>>> defined -- much
>>>>>>>>> more well-defined than "the largest prime".  We have an exact
>>>>>>>>> specification for it, mapping arguments to returned values.
>>>>>>>>> It's just
>>>>>>>>> software engineering to write such things (they erroneously
>>>>>>>>> assume).
>>>>>>>>>
>>>>>>>>> These sorts of proof can always be re-worded so as to avoid the
>>>>>>>>> initial
>>>>>>>>> assumption.  For example, we can start "let p be any prime",
>>>>>>>>> and from p
>>>>>>>>> we construct a prime p' > p.  And for halting, we can start
>>>>>>>>> "let H be
>>>>>>>>> any subroutine of two arguments always returning true or
>>>>>>>>> false". Now,
>>>>>>>>> all the objects /do/ exist.  In the first case, the
>>>>>>>>> construction shows
>>>>>>>>> that no prime is the largest, and in the second it shows that no
>>>>>>>>> subroutine computes the halting function.
>>>>>>>>>
>>>>>>>>> This issue led to another change.  In the last couple of years,
>>>>>>>>> I would
>>>>>>>>> start the course by setting Post's correspondence problem as if
>>>>>>>>> it were
>>>>>>>>> just a fun programming challenge.  As the days passed (and the
>>>>>>>>> course
>>>>>>>>> got into more and more serious material) it would start to
>>>>>>>>> become clear
>>>>>>>>> that this was no ordinary programming challenge.  Many students
>>>>>>>>> started
>>>>>>>>> to suspect that, despite the trivial sounding specification, no
>>>>>>>>> program
>>>>>>>>> could do the job.  I always felt a bit uneasy doing this, as if
>>>>>>>>> I was
>>>>>>>>> not being 100% honest, but it was a very useful learning
>>>>>>>>> experience for
>>>>>>>>> most.
>>>>>>>>>
>>>>>>>>
>>>>>>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>>>>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>>>>>>     yes/no answer to the following question:
>>>>>>>>
>>>>>>>>     Will Jack's answer to this question be no?
>>>>>>>>
>>>>>>>>     Jack can't possibly give a correct yes/no answer to the
>>>>>>>> question.
>>>>>>>>
>>>>>>>> It is an easily verified fact that when Jack's question is posed
>>>>>>>> to Jack
>>>>>>>> that this question is self-contradictory for Jack or anyone else
>>>>>>>> having
>>>>>>>> a pathological relationship to the question.
>>>>>>>
>>>>>>> But the problem is "Jack" here is assumed to be a volitional being.
>>>>>>>
>>>>>>> H is not, it is a program, so before we even ask H what will
>>>>>>> happen, the answer has been fixed by the definition of the codr
>>>>>>> of H.
>>>>>>>
>>>>>>>>
>>>>>>>> It is also clear that when a question has no yes or no answer
>>>>>>>> because
>>>>>>>> it is self-contradictory that this question is aptly classified as
>>>>>>>> incorrect.
>>>>>>>
>>>>>>> And the actual question DOES have a yes or no answer, in this
>>>>>>> case, since H(D,D) says 0 (non-Halting) the actual answer to the
>>>>>>> question does D(D) Halt is YES.
>>>>>>>
>>>>>>> You just confuse yourself by trying to imagine a program that can
>>>>>>> somehow change itself "at will".
>>>>>>>
>>>>>>>>
>>>>>>>> It is incorrect to say that a question is not self-contradictory
>>>>>>>> on the
>>>>>>>> basis that it is not self-contradictory in some contexts. If a
>>>>>>>> question
>>>>>>>> is self-contradictory in some contexts then in these contexts it
>>>>>>>> is an
>>>>>>>> incorrect question.
>>>>>>>
>>>>>>> In what context is "Does the Machine D(D) Halt When run" become
>>>>>>> self-contradictory?
>>>>>> When this question is posed to machine H.
>>>>>>
>>>>>> Jack could be asked the question:
>>>>>> Will Jack answer "no" to this question?
>>>>>>
>>>>>> For Jack it is self-contradictory for others that are not
>>>>>> Jack it is not self-contradictory. Context changes the semantics.
>>>>>>
>>>>>
>>>>> But you are missing the difference. A Decider is a fixed piece of
>>>>> code, so its answer has always been fixed to this question since it
>>>>> has been designed. Thus what it will say isn't a varialbe that can
>>>>> lead to the self-contradiction cycle, but a fixed result that will
>>>>> either be correct or incorrect.
>>>>>
>>>>
>>>> Every input to a Turing machine decider such that both Boolean return
>>>> values are incorrect is an incorrect input.
>>>>
>>>
>>> Except it isn't. The problem is you are looking at two different
>>> machines and two different inputs.
>>>
>> If no one can possibly correctly answer what the correct return value
>> that any H<n> having a pathological relationship to its input D<n>
>> could possibly provide then that is proof that D<n> is an invalid
>> input for H<n> in the same way that any self-contradictory question is
>> an incorrect question.
>>
>
> But you have the wrong Question. The Question is Does D(D) Halt, and
> that HAS a correct answer, since your H(D,D) returns 0, the answer is
> that D(D) does Halt, and thus H was wrong.
>
sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
You ask someone (we'll call him "Jack") to give a truthful
yes/no answer to the following question:

On 6/18/23 10:32 AM, olcott wrote:
> On 6/18/2023 7:02 AM, Richard Damon wrote:
>> On 6/17/23 11:10 PM, olcott wrote:
>>> On 6/17/2023 9:57 PM, Richard Damon wrote:
>>>> On 6/17/23 10:29 PM, olcott wrote:
>>>>> On 6/17/2023 8:31 PM, Richard Damon wrote:
>>>>>> On 6/17/23 7:58 PM, olcott wrote:
>>>>>>> On 6/17/2023 6:13 PM, Richard Damon wrote:
>>>>>>>> On 6/17/23 5:46 PM, olcott wrote:
>>>>>>>>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>
>>>>>>>>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>>>>>>>>> Quesiton, so
>>>>>>>>>>> the answer doesn't apply.
>>>>>>>>>>
>>>>>>>>>> That's an interesting point that would often catch students
>>>>>>>>>> out. And
>>>>>>>>>> the reason /why/ it catches so many out eventually led me to
>>>>>>>>>> stop using
>>>>>>>>>> the proof-by-contradiction argument in my classes.
>>>>>>>>>>
>>>>>>>>>> The thing is, it looks so very much like a self-contradicting
>>>>>>>>>> question
>>>>>>>>>> is being asked.  The students think they can see it right
>>>>>>>>>> there in the
>>>>>>>>>> constructed code: "if H says I halt, I don't halt!".
>>>>>>>>>>
>>>>>>>>>> Of course, they are wrong.  The code is /not/ there.  The code
>>>>>>>>>> calls a
>>>>>>>>>> function that does not exist, so "it" (the constructed code,
>>>>>>>>>> the whole
>>>>>>>>>> program) does not exist either.
>>>>>>>>>>
>>>>>>>>>> The fact that it's code, and the students are almost all
>>>>>>>>>> programmers and
>>>>>>>>>> not mathematicians, makes it worse.  A mathematician seeing
>>>>>>>>>> "let p be
>>>>>>>>>> the largest prime" does not assume that such a p exists.  So
>>>>>>>>>> when a
>>>>>>>>>> prime number p' > p is constructed from p, this is not seen as a
>>>>>>>>>> "self-contradictory number" because neither p nor p' exist.
>>>>>>>>>> But the
>>>>>>>>>> halting theorem is even more deceptive for programmers,
>>>>>>>>>> because the
>>>>>>>>>> desired function, H (or whatever), appears to be so well
>>>>>>>>>> defined -- much
>>>>>>>>>> more well-defined than "the largest prime".  We have an exact
>>>>>>>>>> specification for it, mapping arguments to returned values.
>>>>>>>>>> It's just
>>>>>>>>>> software engineering to write such things (they erroneously
>>>>>>>>>> assume).
>>>>>>>>>>
>>>>>>>>>> These sorts of proof can always be re-worded so as to avoid
>>>>>>>>>> the initial
>>>>>>>>>> assumption.  For example, we can start "let p be any prime",
>>>>>>>>>> and from p
>>>>>>>>>> we construct a prime p' > p.  And for halting, we can start
>>>>>>>>>> "let H be
>>>>>>>>>> any subroutine of two arguments always returning true or
>>>>>>>>>> false". Now,
>>>>>>>>>> all the objects /do/ exist.  In the first case, the
>>>>>>>>>> construction shows
>>>>>>>>>> that no prime is the largest, and in the second it shows that no
>>>>>>>>>> subroutine computes the halting function.
>>>>>>>>>>
>>>>>>>>>> This issue led to another change.  In the last couple of
>>>>>>>>>> years, I would
>>>>>>>>>> start the course by setting Post's correspondence problem as
>>>>>>>>>> if it were
>>>>>>>>>> just a fun programming challenge.  As the days passed (and the
>>>>>>>>>> course
>>>>>>>>>> got into more and more serious material) it would start to
>>>>>>>>>> become clear
>>>>>>>>>> that this was no ordinary programming challenge.  Many
>>>>>>>>>> students started
>>>>>>>>>> to suspect that, despite the trivial sounding specification,
>>>>>>>>>> no program
>>>>>>>>>> could do the job.  I always felt a bit uneasy doing this, as
>>>>>>>>>> if I was
>>>>>>>>>> not being 100% honest, but it was a very useful learning
>>>>>>>>>> experience for
>>>>>>>>>> most.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>>>>>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>>>>>>>     yes/no answer to the following question:
>>>>>>>>>
>>>>>>>>>     Will Jack's answer to this question be no?
>>>>>>>>>
>>>>>>>>>     Jack can't possibly give a correct yes/no answer to the
>>>>>>>>> question.
>>>>>>>>>
>>>>>>>>> It is an easily verified fact that when Jack's question is
>>>>>>>>> posed to Jack
>>>>>>>>> that this question is self-contradictory for Jack or anyone
>>>>>>>>> else having
>>>>>>>>> a pathological relationship to the question.
>>>>>>>>
>>>>>>>> But the problem is "Jack" here is assumed to be a volitional being.
>>>>>>>>
>>>>>>>> H is not, it is a program, so before we even ask H what will
>>>>>>>> happen, the answer has been fixed by the definition of the codr
>>>>>>>> of H.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is also clear that when a question has no yes or no answer
>>>>>>>>> because
>>>>>>>>> it is self-contradictory that this question is aptly classified as
>>>>>>>>> incorrect.
>>>>>>>>
>>>>>>>> And the actual question DOES have a yes or no answer, in this
>>>>>>>> case, since H(D,D) says 0 (non-Halting) the actual answer to the
>>>>>>>> question does D(D) Halt is YES.
>>>>>>>>
>>>>>>>> You just confuse yourself by trying to imagine a program that
>>>>>>>> can somehow change itself "at will".
>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is incorrect to say that a question is not
>>>>>>>>> self-contradictory on the
>>>>>>>>> basis that it is not self-contradictory in some contexts. If a
>>>>>>>>> question
>>>>>>>>> is self-contradictory in some contexts then in these contexts
>>>>>>>>> it is an
>>>>>>>>> incorrect question.
>>>>>>>>
>>>>>>>> In what context is "Does the Machine D(D) Halt When run" become
>>>>>>>> self-contradictory?
>>>>>>> When this question is posed to machine H.
>>>>>>>
>>>>>>> Jack could be asked the question:
>>>>>>> Will Jack answer "no" to this question?
>>>>>>>
>>>>>>> For Jack it is self-contradictory for others that are not
>>>>>>> Jack it is not self-contradictory. Context changes the semantics.
>>>>>>>
>>>>>>
>>>>>> But you are missing the difference. A Decider is a fixed piece of
>>>>>> code, so its answer has always been fixed to this question since
>>>>>> it has been designed. Thus what it will say isn't a varialbe that
>>>>>> can lead to the self-contradiction cycle, but a fixed result that
>>>>>> will either be correct or incorrect.
>>>>>>
>>>>>
>>>>> Every input to a Turing machine decider such that both Boolean return
>>>>> values are incorrect is an incorrect input.
>>>>>
>>>>
>>>> Except it isn't. The problem is you are looking at two different
>>>> machines and two different inputs.
>>>>
>>> If no one can possibly correctly answer what the correct return value
>>> that any H<n> having a pathological relationship to its input D<n>
>>> could possibly provide then that is proof that D<n> is an invalid
>>> input for H<n> in the same way that any self-contradictory question
>>> is an incorrect question.
>>>
>>
>> But you have the wrong Question. The Question is Does D(D) Halt, and
>> that HAS a correct answer, since your H(D,D) returns 0, the answer is
>> that D(D) does Halt, and thus H was wrong.
>>
> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>    You ask someone (we'll call him "Jack") to give a truthful
>    yes/no answer to the following question:
>
>    Will Jack's answer to this question be no?
>
> For Jack the question is self-contradictory for others that
> are not Jack it is not self-contradictory.
>
> The context (of who is asked) changes the semantics.
>
> Every question that lacks a correct yes/no answer because
> the question is self-contradictory is an incorrect question.
>
> If you are not a mere Troll you will agree with this.
>

On 6/18/2023 11:31 AM, Richard Damon wrote:
> On 6/18/23 10:32 AM, olcott wrote:
>> On 6/18/2023 7:02 AM, Richard Damon wrote:
>>> On 6/17/23 11:10 PM, olcott wrote:
>>>> On 6/17/2023 9:57 PM, Richard Damon wrote:
>>>>> On 6/17/23 10:29 PM, olcott wrote:
>>>>>> On 6/17/2023 8:31 PM, Richard Damon wrote:
>>>>>>> On 6/17/23 7:58 PM, olcott wrote:
>>>>>>>> On 6/17/2023 6:13 PM, Richard Damon wrote:
>>>>>>>>> On 6/17/23 5:46 PM, olcott wrote:
>>>>>>>>>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>>
>>>>>>>>>>>> Except that the Halting Problem isn't a "Self-Contradictory"
>>>>>>>>>>>> Quesiton, so
>>>>>>>>>>>> the answer doesn't apply.
>>>>>>>>>>>
>>>>>>>>>>> That's an interesting point that would often catch students
>>>>>>>>>>> out. And
>>>>>>>>>>> the reason /why/ it catches so many out eventually led me to
>>>>>>>>>>> stop using
>>>>>>>>>>> the proof-by-contradiction argument in my classes.
>>>>>>>>>>>
>>>>>>>>>>> The thing is, it looks so very much like a self-contradicting
>>>>>>>>>>> question
>>>>>>>>>>> is being asked.  The students think they can see it right
>>>>>>>>>>> there in the
>>>>>>>>>>> constructed code: "if H says I halt, I don't halt!".
>>>>>>>>>>>
>>>>>>>>>>> Of course, they are wrong.  The code is /not/ there.  The
>>>>>>>>>>> code calls a
>>>>>>>>>>> function that does not exist, so "it" (the constructed code,
>>>>>>>>>>> the whole
>>>>>>>>>>> program) does not exist either.
>>>>>>>>>>>
>>>>>>>>>>> The fact that it's code, and the students are almost all
>>>>>>>>>>> programmers and
>>>>>>>>>>> not mathematicians, makes it worse.  A mathematician seeing
>>>>>>>>>>> "let p be
>>>>>>>>>>> the largest prime" does not assume that such a p exists.  So
>>>>>>>>>>> when a
>>>>>>>>>>> prime number p' > p is constructed from p, this is not seen as a
>>>>>>>>>>> "self-contradictory number" because neither p nor p' exist.
>>>>>>>>>>> But the
>>>>>>>>>>> halting theorem is even more deceptive for programmers,
>>>>>>>>>>> because the
>>>>>>>>>>> desired function, H (or whatever), appears to be so well
>>>>>>>>>>> defined -- much
>>>>>>>>>>> more well-defined than "the largest prime".  We have an exact
>>>>>>>>>>> specification for it, mapping arguments to returned values.
>>>>>>>>>>> It's just
>>>>>>>>>>> software engineering to write such things (they erroneously
>>>>>>>>>>> assume).
>>>>>>>>>>>
>>>>>>>>>>> These sorts of proof can always be re-worded so as to avoid
>>>>>>>>>>> the initial
>>>>>>>>>>> assumption.  For example, we can start "let p be any prime",
>>>>>>>>>>> and from p
>>>>>>>>>>> we construct a prime p' > p.  And for halting, we can start
>>>>>>>>>>> "let H be
>>>>>>>>>>> any subroutine of two arguments always returning true or
>>>>>>>>>>> false". Now,
>>>>>>>>>>> all the objects /do/ exist.  In the first case, the
>>>>>>>>>>> construction shows
>>>>>>>>>>> that no prime is the largest, and in the second it shows that no
>>>>>>>>>>> subroutine computes the halting function.
>>>>>>>>>>>
>>>>>>>>>>> This issue led to another change.  In the last couple of
>>>>>>>>>>> years, I would
>>>>>>>>>>> start the course by setting Post's correspondence problem as
>>>>>>>>>>> if it were
>>>>>>>>>>> just a fun programming challenge.  As the days passed (and
>>>>>>>>>>> the course
>>>>>>>>>>> got into more and more serious material) it would start to
>>>>>>>>>>> become clear
>>>>>>>>>>> that this was no ordinary programming challenge.  Many
>>>>>>>>>>> students started
>>>>>>>>>>> to suspect that, despite the trivial sounding specification,
>>>>>>>>>>> no program
>>>>>>>>>>> could do the job.  I always felt a bit uneasy doing this, as
>>>>>>>>>>> if I was
>>>>>>>>>>> not being 100% honest, but it was a very useful learning
>>>>>>>>>>> experience for
>>>>>>>>>>> most.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>>>>>>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>>>>>>>>     yes/no answer to the following question:
>>>>>>>>>>
>>>>>>>>>>     Will Jack's answer to this question be no?
>>>>>>>>>>
>>>>>>>>>>     Jack can't possibly give a correct yes/no answer to the
>>>>>>>>>> question.
>>>>>>>>>>
>>>>>>>>>> It is an easily verified fact that when Jack's question is
>>>>>>>>>> posed to Jack
>>>>>>>>>> that this question is self-contradictory for Jack or anyone
>>>>>>>>>> else having
>>>>>>>>>> a pathological relationship to the question.
>>>>>>>>>
>>>>>>>>> But the problem is "Jack" here is assumed to be a volitional
>>>>>>>>> being.
>>>>>>>>>
>>>>>>>>> H is not, it is a program, so before we even ask H what will
>>>>>>>>> happen, the answer has been fixed by the definition of the codr
>>>>>>>>> of H.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is also clear that when a question has no yes or no answer
>>>>>>>>>> because
>>>>>>>>>> it is self-contradictory that this question is aptly
>>>>>>>>>> classified as
>>>>>>>>>> incorrect.
>>>>>>>>>
>>>>>>>>> And the actual question DOES have a yes or no answer, in this
>>>>>>>>> case, since H(D,D) says 0 (non-Halting) the actual answer to
>>>>>>>>> the question does D(D) Halt is YES.
>>>>>>>>>
>>>>>>>>> You just confuse yourself by trying to imagine a program that
>>>>>>>>> can somehow change itself "at will".
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is incorrect to say that a question is not
>>>>>>>>>> self-contradictory on the
>>>>>>>>>> basis that it is not self-contradictory in some contexts. If a
>>>>>>>>>> question
>>>>>>>>>> is self-contradictory in some contexts then in these contexts
>>>>>>>>>> it is an
>>>>>>>>>> incorrect question.
>>>>>>>>>
>>>>>>>>> In what context is "Does the Machine D(D) Halt When run" become
>>>>>>>>> self-contradictory?
>>>>>>>> When this question is posed to machine H.
>>>>>>>>
>>>>>>>> Jack could be asked the question:
>>>>>>>> Will Jack answer "no" to this question?
>>>>>>>>
>>>>>>>> For Jack it is self-contradictory for others that are not
>>>>>>>> Jack it is not self-contradictory. Context changes the semantics.
>>>>>>>>
>>>>>>>
>>>>>>> But you are missing the difference. A Decider is a fixed piece of
>>>>>>> code, so its answer has always been fixed to this question since
>>>>>>> it has been designed. Thus what it will say isn't a varialbe that
>>>>>>> can lead to the self-contradiction cycle, but a fixed result that
>>>>>>> will either be correct or incorrect.
>>>>>>>
>>>>>>
>>>>>> Every input to a Turing machine decider such that both Boolean return
>>>>>> values are incorrect is an incorrect input.
>>>>>>
>>>>>
>>>>> Except it isn't. The problem is you are looking at two different
>>>>> machines and two different inputs.
>>>>>
>>>> If no one can possibly correctly answer what the correct return
>>>> value that any H<n> having a pathological relationship to its input
>>>> D<n> could possibly provide then that is proof that D<n> is an
>>>> invalid input for H<n> in the same way that any self-contradictory
>>>> question is an incorrect question.
>>>>
>>>
>>> But you have the wrong Question. The Question is Does D(D) Halt, and
>>> that HAS a correct answer, since your H(D,D) returns 0, the answer is
>>> that D(D) does Halt, and thus H was wrong.
>>>
>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>     You ask someone (we'll call him "Jack") to give a truthful
>>     yes/no answer to the following question:
>>
>>     Will Jack's answer to this question be no?
>>
>> For Jack the question is self-contradictory for others that
>> are not Jack it is not self-contradictory.
>>
>> The context (of who is asked) changes the semantics.
>>
>> Every question that lacks a correct yes/no answer because
>> the question is self-contradictory is an incorrect question.
>>
>> If you are not a mere Troll you will agree with this.
>>
>
> But the ACTUAL QUESTION DOES have a correct answer.
The actual question posed to Jack has no correct answer.
The actual question posed to anyone else is a semantically
different question even though the words are the same.

On 6/18/23 12:41 PM, olcott wrote:
> On 6/18/2023 11:31 AM, Richard Damon wrote:
>> On 6/18/23 10:32 AM, olcott wrote:
>>> On 6/18/2023 7:02 AM, Richard Damon wrote:
>>>> On 6/17/23 11:10 PM, olcott wrote:
>>>>> On 6/17/2023 9:57 PM, Richard Damon wrote:
>>>>>> On 6/17/23 10:29 PM, olcott wrote:
>>>>>>> On 6/17/2023 8:31 PM, Richard Damon wrote:
>>>>>>>> On 6/17/23 7:58 PM, olcott wrote:
>>>>>>>>> On 6/17/2023 6:13 PM, Richard Damon wrote:
>>>>>>>>>> On 6/17/23 5:46 PM, olcott wrote:
>>>>>>>>>>> On 6/17/2023 4:09 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> Except that the Halting Problem isn't a
>>>>>>>>>>>>> "Self-Contradictory" Quesiton, so
>>>>>>>>>>>>> the answer doesn't apply.
>>>>>>>>>>>>
>>>>>>>>>>>> That's an interesting point that would often catch students
>>>>>>>>>>>> out. And
>>>>>>>>>>>> the reason /why/ it catches so many out eventually led me to
>>>>>>>>>>>> stop using
>>>>>>>>>>>> the proof-by-contradiction argument in my classes.
>>>>>>>>>>>>
>>>>>>>>>>>> The thing is, it looks so very much like a
>>>>>>>>>>>> self-contradicting question
>>>>>>>>>>>> is being asked.  The students think they can see it right
>>>>>>>>>>>> there in the
>>>>>>>>>>>> constructed code: "if H says I halt, I don't halt!".
>>>>>>>>>>>>
>>>>>>>>>>>> Of course, they are wrong.  The code is /not/ there.  The
>>>>>>>>>>>> code calls a
>>>>>>>>>>>> function that does not exist, so "it" (the constructed code,
>>>>>>>>>>>> the whole
>>>>>>>>>>>> program) does not exist either.
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that it's code, and the students are almost all
>>>>>>>>>>>> programmers and
>>>>>>>>>>>> not mathematicians, makes it worse.  A mathematician seeing
>>>>>>>>>>>> "let p be
>>>>>>>>>>>> the largest prime" does not assume that such a p exists.  So
>>>>>>>>>>>> when a
>>>>>>>>>>>> prime number p' > p is constructed from p, this is not seen
>>>>>>>>>>>> as a
>>>>>>>>>>>> "self-contradictory number" because neither p nor p' exist.
>>>>>>>>>>>> But the
>>>>>>>>>>>> halting theorem is even more deceptive for programmers,
>>>>>>>>>>>> because the
>>>>>>>>>>>> desired function, H (or whatever), appears to be so well
>>>>>>>>>>>> defined -- much
>>>>>>>>>>>> more well-defined than "the largest prime".  We have an exact
>>>>>>>>>>>> specification for it, mapping arguments to returned values.
>>>>>>>>>>>> It's just
>>>>>>>>>>>> software engineering to write such things (they erroneously
>>>>>>>>>>>> assume).
>>>>>>>>>>>>
>>>>>>>>>>>> These sorts of proof can always be re-worded so as to avoid
>>>>>>>>>>>> the initial
>>>>>>>>>>>> assumption.  For example, we can start "let p be any prime",
>>>>>>>>>>>> and from p
>>>>>>>>>>>> we construct a prime p' > p.  And for halting, we can start
>>>>>>>>>>>> "let H be
>>>>>>>>>>>> any subroutine of two arguments always returning true or
>>>>>>>>>>>> false". Now,
>>>>>>>>>>>> all the objects /do/ exist.  In the first case, the
>>>>>>>>>>>> construction shows
>>>>>>>>>>>> that no prime is the largest, and in the second it shows
>>>>>>>>>>>> that no
>>>>>>>>>>>> subroutine computes the halting function.
>>>>>>>>>>>>
>>>>>>>>>>>> This issue led to another change.  In the last couple of
>>>>>>>>>>>> years, I would
>>>>>>>>>>>> start the course by setting Post's correspondence problem as
>>>>>>>>>>>> if it were
>>>>>>>>>>>> just a fun programming challenge.  As the days passed (and
>>>>>>>>>>>> the course
>>>>>>>>>>>> got into more and more serious material) it would start to
>>>>>>>>>>>> become clear
>>>>>>>>>>>> that this was no ordinary programming challenge.  Many
>>>>>>>>>>>> students started
>>>>>>>>>>>> to suspect that, despite the trivial sounding specification,
>>>>>>>>>>>> no program
>>>>>>>>>>>> could do the job.  I always felt a bit uneasy doing this, as
>>>>>>>>>>>> if I was
>>>>>>>>>>>> not being 100% honest, but it was a very useful learning
>>>>>>>>>>>> experience for
>>>>>>>>>>>> most.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>>>>>>>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>>>>>>>>>     yes/no answer to the following question:
>>>>>>>>>>>
>>>>>>>>>>>     Will Jack's answer to this question be no?
>>>>>>>>>>>
>>>>>>>>>>>     Jack can't possibly give a correct yes/no answer to the
>>>>>>>>>>> question.
>>>>>>>>>>>
>>>>>>>>>>> It is an easily verified fact that when Jack's question is
>>>>>>>>>>> posed to Jack
>>>>>>>>>>> that this question is self-contradictory for Jack or anyone
>>>>>>>>>>> else having
>>>>>>>>>>> a pathological relationship to the question.
>>>>>>>>>>
>>>>>>>>>> But the problem is "Jack" here is assumed to be a volitional
>>>>>>>>>> being.
>>>>>>>>>>
>>>>>>>>>> H is not, it is a program, so before we even ask H what will
>>>>>>>>>> happen, the answer has been fixed by the definition of the
>>>>>>>>>> codr of H.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is also clear that when a question has no yes or no answer
>>>>>>>>>>> because
>>>>>>>>>>> it is self-contradictory that this question is aptly
>>>>>>>>>>> classified as
>>>>>>>>>>> incorrect.
>>>>>>>>>>
>>>>>>>>>> And the actual question DOES have a yes or no answer, in this
>>>>>>>>>> case, since H(D,D) says 0 (non-Halting) the actual answer to
>>>>>>>>>> the question does D(D) Halt is YES.
>>>>>>>>>>
>>>>>>>>>> You just confuse yourself by trying to imagine a program that
>>>>>>>>>> can somehow change itself "at will".
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is incorrect to say that a question is not
>>>>>>>>>>> self-contradictory on the
>>>>>>>>>>> basis that it is not self-contradictory in some contexts. If
>>>>>>>>>>> a question
>>>>>>>>>>> is self-contradictory in some contexts then in these contexts
>>>>>>>>>>> it is an
>>>>>>>>>>> incorrect question.
>>>>>>>>>>
>>>>>>>>>> In what context is "Does the Machine D(D) Halt When run"
>>>>>>>>>> become self-contradictory?
>>>>>>>>> When this question is posed to machine H.
>>>>>>>>>
>>>>>>>>> Jack could be asked the question:
>>>>>>>>> Will Jack answer "no" to this question?
>>>>>>>>>
>>>>>>>>> For Jack it is self-contradictory for others that are not
>>>>>>>>> Jack it is not self-contradictory. Context changes the semantics.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But you are missing the difference. A Decider is a fixed piece
>>>>>>>> of code, so its answer has always been fixed to this question
>>>>>>>> since it has been designed. Thus what it will say isn't a
>>>>>>>> varialbe that can lead to the self-contradiction cycle, but a
>>>>>>>> fixed result that will either be correct or incorrect.
>>>>>>>>
>>>>>>>
>>>>>>> Every input to a Turing machine decider such that both Boolean
>>>>>>> return
>>>>>>> values are incorrect is an incorrect input.
>>>>>>>
>>>>>>
>>>>>> Except it isn't. The problem is you are looking at two different
>>>>>> machines and two different inputs.
>>>>>>
>>>>> If no one can possibly correctly answer what the correct return
>>>>> value that any H<n> having a pathological relationship to its input
>>>>> D<n> could possibly provide then that is proof that D<n> is an
>>>>> invalid input for H<n> in the same way that any self-contradictory
>>>>> question is an incorrect question.
>>>>>
>>>>
>>>> But you have the wrong Question. The Question is Does D(D) Halt, and
>>>> that HAS a correct answer, since your H(D,D) returns 0, the answer
>>>> is that D(D) does Halt, and thus H was wrong.
>>>>
>>> sci.logic Daryl McCullough Jun 25, 2004, 6:30:39 PM
>>>     You ask someone (we'll call him "Jack") to give a truthful
>>>     yes/no answer to the following question:
>>>
>>>     Will Jack's answer to this question be no?
>>>
>>> For Jack the question is self-contradictory for others that
>>> are not Jack it is not self-contradictory.
>>>
>>> The context (of who is asked) changes the semantics.
>>>
>>> Every question that lacks a correct yes/no answer because
>>> the question is self-contradictory is an incorrect question.
>>>
>>> If you are not a mere Troll you will agree with this.
>>>
>>
>> But the ACTUAL QUESTION DOES have a correct answer.
> The actual question posed to Jack has no correct answer.
> The actual question posed to anyone else is a semantically
> different question even though the words are the same.
>