On 6/18/2023 11:54 AM, Richard Damon wrote:
> 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.
>>
>
> But the question to Jack isn't the question you are actaully saying
> doesn't have an answer.
>
The question posed to Jack does not have an answer because within the
context that the question is posed to Jack it is self-contradictory.
You can ignore that context matters yet that is not any rebuttal.

On 6/18/23 1:09 PM, olcott wrote:
> On 6/18/2023 11:54 AM, Richard Damon wrote:
>> 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.
>>>
>>
>> But the question to Jack isn't the question you are actaully saying
>> doesn't have an answer.
>>
> The question posed to Jack does not have an answer because within the
> context that the question is posed to Jack it is self-contradictory.
> You can ignore that context matters yet that is not any rebuttal.
>

On 6/18/2023 12:46 PM, Richard Damon wrote:
> On 6/18/23 1:09 PM, olcott wrote:
>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>> 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.
>>>>
>>>
>>> But the question to Jack isn't the question you are actaully saying
>>> doesn't have an answer.
>>>
>> The question posed to Jack does not have an answer because within the
>> context that the question is posed to Jack it is self-contradictory.
>> You can ignore that context matters yet that is not any rebuttal.
>>
>
> Right, but that has ZERO bearig on the Halting Problem,
That is great we made excellent progress on this.

On 6/18/23 2:05 PM, olcott wrote:
> On 6/18/2023 12:46 PM, Richard Damon wrote:
>> On 6/18/23 1:09 PM, olcott wrote:
>>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>>> 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.
>>>>>
>>>>
>>>> But the question to Jack isn't the question you are actaully saying
>>>> doesn't have an answer.
>>>>
>>> The question posed to Jack does not have an answer because within the
>>> context that the question is posed to Jack it is self-contradictory.
>>> You can ignore that context matters yet that is not any rebuttal.
>>>
>>
>> Right, but that has ZERO bearig on the Halting Problem,
> That is great we made excellent progress on this.
>
> When ChatGPT understood that Jack's question is self-contradictory for
> Jack then it was also able to understand the following isomorphism:
>
> For every H<n> on pathological input D<n> both Boolean return values
> from H<n> are incorrect for D<n> proving that D<n> is isomorphic to a
> self-contradictory question for every H<n>.
>

On 6/18/2023 1:20 PM, Richard Damon wrote:
> On 6/18/23 2:05 PM, olcott wrote:
>> On 6/18/2023 12:46 PM, Richard Damon wrote:
>>> On 6/18/23 1:09 PM, olcott wrote:
>>>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>>>> 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.
>>>>>>
>>>>>
>>>>> But the question to Jack isn't the question you are actaully saying
>>>>> doesn't have an answer.
>>>>>
>>>> The question posed to Jack does not have an answer because within the
>>>> context that the question is posed to Jack it is self-contradictory.
>>>> You can ignore that context matters yet that is not any rebuttal.
>>>>
>>>
>>> Right, but that has ZERO bearig on the Halting Problem,
>> That is great we made excellent progress on this.
>>
>> When ChatGPT understood that Jack's question is self-contradictory for
>> Jack then it was also able to understand the following isomorphism:
>>
>> For every H<n> on pathological input D<n> both Boolean return values
>> from H<n> are incorrect for D<n> proving that D<n> is isomorphic to a
>> self-contradictory question for every H<n>.
>>
>
> No, because a given H<n> can only give one result,
In other words you fail to understand that when Jack's question is posed
to someone else that it remains self-contradictory.

On 6/18/23 2:30 PM, olcott wrote:
> On 6/18/2023 1:20 PM, Richard Damon wrote:
>> On 6/18/23 2:05 PM, olcott wrote:
>>> On 6/18/2023 12:46 PM, Richard Damon wrote:
>>>> On 6/18/23 1:09 PM, olcott wrote:
>>>>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>>>>> 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.
>>>>>>>
>>>>>>
>>>>>> But the question to Jack isn't the question you are actaully
>>>>>> saying doesn't have an answer.
>>>>>>
>>>>> The question posed to Jack does not have an answer because within the
>>>>> context that the question is posed to Jack it is self-contradictory.
>>>>> You can ignore that context matters yet that is not any rebuttal.
>>>>>
>>>>
>>>> Right, but that has ZERO bearig on the Halting Problem,
>>> That is great we made excellent progress on this.
>>>
>>> When ChatGPT understood that Jack's question is self-contradictory for
>>> Jack then it was also able to understand the following isomorphism:
>>>
>>> For every H<n> on pathological input D<n> both Boolean return values
>>> from H<n> are incorrect for D<n> proving that D<n> is isomorphic to a
>>> self-contradictory question for every H<n>.
>>>
>>
>> No, because a given H<n> can only give one result,
> In other words you fail to understand that when Jack's question is posed
> to someone else that it remains self-contradictory.
>

On 6/18/2023 1:20 PM, Richard Damon wrote:
> On 6/18/23 2:05 PM, olcott wrote:
>> On 6/18/2023 12:46 PM, Richard Damon wrote:
>>> On 6/18/23 1:09 PM, olcott wrote:
>>>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>>>> 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.
>>>>>>
>>>>>
>>>>> But the question to Jack isn't the question you are actaully saying
>>>>> doesn't have an answer.
>>>>>
>>>> The question posed to Jack does not have an answer because within the
>>>> context that the question is posed to Jack it is self-contradictory.
>>>> You can ignore that context matters yet that is not any rebuttal.
>>>>
>>>
>>> Right, but that has ZERO bearig on the Halting Problem,
>> That is great we made excellent progress on this.
>>
>> When ChatGPT understood that Jack's question is self-contradictory for
>> Jack then it was also able to understand the following isomorphism:
>>
>> For every H<n> on pathological input D<n> both Boolean return values
>> from H<n> are incorrect for D<n> proving that D<n> is isomorphic to a
>> self-contradictory question for every H<n>.
>>
>
> No, because a given H<n> can only give one result,
Some of the elements of H<n>/D<n> are identical except for the return
value from H. In both of these cases the return value is incorrect.

On 6/18/23 2:47 PM, olcott wrote:
> On 6/18/2023 1:20 PM, Richard Damon wrote:
>> On 6/18/23 2:05 PM, olcott wrote:
>>> On 6/18/2023 12:46 PM, Richard Damon wrote:
>>>> On 6/18/23 1:09 PM, olcott wrote:
>>>>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>>>>> 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.
>>>>>>>
>>>>>>
>>>>>> But the question to Jack isn't the question you are actaully
>>>>>> saying doesn't have an answer.
>>>>>>
>>>>> The question posed to Jack does not have an answer because within the
>>>>> context that the question is posed to Jack it is self-contradictory.
>>>>> You can ignore that context matters yet that is not any rebuttal.
>>>>>
>>>>
>>>> Right, but that has ZERO bearig on the Halting Problem,
>>> That is great we made excellent progress on this.
>>>
>>> When ChatGPT understood that Jack's question is self-contradictory for
>>> Jack then it was also able to understand the following isomorphism:
>>>
>>> For every H<n> on pathological input D<n> both Boolean return values
>>> from H<n> are incorrect for D<n> proving that D<n> is isomorphic to a
>>> self-contradictory question for every H<n>.
>>>
>>
>> No, because a given H<n> can only give one result,
> Some of the elements of H<n>/D<n> are identical except for the return
> value from H. In both of these cases the return value is incorrect.

On 6/18/2023 2:19 PM, Richard Damon wrote:
> On 6/18/23 2:47 PM, olcott wrote:
>> On 6/18/2023 1:20 PM, Richard Damon wrote:
>>> On 6/18/23 2:05 PM, olcott wrote:
>>>> On 6/18/2023 12:46 PM, Richard Damon wrote:
>>>>> On 6/18/23 1:09 PM, olcott wrote:
>>>>>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>>>>>> 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.
>>>>>>>>
>>>>>>>
>>>>>>> But the question to Jack isn't the question you are actaully
>>>>>>> saying doesn't have an answer.
>>>>>>>
>>>>>> The question posed to Jack does not have an answer because within the
>>>>>> context that the question is posed to Jack it is self-contradictory.
>>>>>> You can ignore that context matters yet that is not any rebuttal.
>>>>>>
>>>>>
>>>>> Right, but that has ZERO bearig on the Halting Problem,
>>>> That is great we made excellent progress on this.
>>>>
>>>> When ChatGPT understood that Jack's question is self-contradictory for
>>>> Jack then it was also able to understand the following isomorphism:
>>>>
>>>> For every H<n> on pathological input D<n> both Boolean return values
>>>> from H<n> are incorrect for D<n> proving that D<n> is isomorphic to
>>>> a self-contradictory question for every H<n>.
>>>>
>>>
>>> No, because a given H<n> can only give one result,
>> Some of the elements of H<n>/D<n> are identical except for the return
>> value from H. In both of these cases the return value is incorrect.
>
> Nope, can't be.

On 6/18/23 3:26 PM, olcott wrote:
> On 6/18/2023 2:19 PM, Richard Damon wrote:
>> On 6/18/23 2:47 PM, olcott wrote:
>>> On 6/18/2023 1:20 PM, Richard Damon wrote:
>>>> On 6/18/23 2:05 PM, olcott wrote:
>>>>> On 6/18/2023 12:46 PM, Richard Damon wrote:
>>>>>> On 6/18/23 1:09 PM, olcott wrote:
>>>>>>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But the question to Jack isn't the question you are actaully
>>>>>>>> saying doesn't have an answer.
>>>>>>>>
>>>>>>> The question posed to Jack does not have an answer because within
>>>>>>> the
>>>>>>> context that the question is posed to Jack it is self-contradictory.
>>>>>>> You can ignore that context matters yet that is not any rebuttal.
>>>>>>>
>>>>>>
>>>>>> Right, but that has ZERO bearig on the Halting Problem,
>>>>> That is great we made excellent progress on this.
>>>>>
>>>>> When ChatGPT understood that Jack's question is self-contradictory for
>>>>> Jack then it was also able to understand the following isomorphism:
>>>>>
>>>>> For every H<n> on pathological input D<n> both Boolean return
>>>>> values from H<n> are incorrect for D<n> proving that D<n> is
>>>>> isomorphic to a self-contradictory question for every H<n>.
>>>>>
>>>>
>>>> No, because a given H<n> can only give one result,
>>> Some of the elements of H<n>/D<n> are identical except for the return
>>> value from H. In both of these cases the return value is incorrect.
>>
>> Nope, can't be.
>
> The only difference between otherwise identical pairs of pairs H<n>/D<n>
> and H<m>/D<m> is the single integer values of 0/1 within H<n> and H<m>
> respectively thus proving that both True and False are the wrong return
> value for the identical finite string pairs D<n>/D<m>.
>
>

On 6/18/2023 3:10 PM, Richard Damon wrote:
> On 6/18/23 3:26 PM, olcott wrote:
>> On 6/18/2023 2:19 PM, Richard Damon wrote:
>>> On 6/18/23 2:47 PM, olcott wrote:
>>>> On 6/18/2023 1:20 PM, Richard Damon wrote:
>>>>> On 6/18/23 2:05 PM, olcott wrote:
>>>>>> On 6/18/2023 12:46 PM, Richard Damon wrote:
>>>>>>> On 6/18/23 1:09 PM, olcott wrote:
>>>>>>>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But the question to Jack isn't the question you are actaully
>>>>>>>>> saying doesn't have an answer.
>>>>>>>>>
>>>>>>>> The question posed to Jack does not have an answer because
>>>>>>>> within the
>>>>>>>> context that the question is posed to Jack it is
>>>>>>>> self-contradictory.
>>>>>>>> You can ignore that context matters yet that is not any rebuttal.
>>>>>>>>
>>>>>>>
>>>>>>> Right, but that has ZERO bearig on the Halting Problem,
>>>>>> That is great we made excellent progress on this.
>>>>>>
>>>>>> When ChatGPT understood that Jack's question is self-contradictory
>>>>>> for
>>>>>> Jack then it was also able to understand the following isomorphism:
>>>>>>
>>>>>> For every H<n> on pathological input D<n> both Boolean return
>>>>>> values from H<n> are incorrect for D<n> proving that D<n> is
>>>>>> isomorphic to a self-contradictory question for every H<n>.
>>>>>>
>>>>>
>>>>> No, because a given H<n> can only give one result,
>>>> Some of the elements of H<n>/D<n> are identical except for the return
>>>> value from H. In both of these cases the return value is incorrect.
>>>
>>> Nope, can't be.
>>
>> The only difference between otherwise identical pairs of pairs H<n>/D<n>
>> and H<m>/D<m> is the single integer values of 0/1 within H<n> and H<m>
>> respectively thus proving that both True and False are the wrong return
>> value for the identical finite string pairs D<n>/D<m>.
>>
>>
>
> So they are different programs. Different is different. Almost the same
> is not the same.
>
> Unless you are claiming that 1 is the same as 0, they are different.
>
> So, your claim is based on a LIE, or you are admitting you are insane.

On 6/18/23 7:43 PM, olcott wrote:
> On 6/18/2023 3:10 PM, Richard Damon wrote:
>> On 6/18/23 3:26 PM, olcott wrote:
>>> On 6/18/2023 2:19 PM, Richard Damon wrote:
>>>> On 6/18/23 2:47 PM, olcott wrote:
>>>>> On 6/18/2023 1:20 PM, Richard Damon wrote:
>>>>>> On 6/18/23 2:05 PM, olcott wrote:
>>>>>>> On 6/18/2023 12:46 PM, Richard Damon wrote:
>>>>>>>> On 6/18/23 1:09 PM, olcott wrote:
>>>>>>>>> On 6/18/2023 11:54 AM, Richard Damon wrote:
>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But the question to Jack isn't the question you are actaully
>>>>>>>>>> saying doesn't have an answer.
>>>>>>>>>>
>>>>>>>>> The question posed to Jack does not have an answer because
>>>>>>>>> within the
>>>>>>>>> context that the question is posed to Jack it is
>>>>>>>>> self-contradictory.
>>>>>>>>> You can ignore that context matters yet that is not any rebuttal.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, but that has ZERO bearig on the Halting Problem,
>>>>>>> That is great we made excellent progress on this.
>>>>>>>
>>>>>>> When ChatGPT understood that Jack's question is
>>>>>>> self-contradictory for
>>>>>>> Jack then it was also able to understand the following isomorphism:
>>>>>>>
>>>>>>> For every H<n> on pathological input D<n> both Boolean return
>>>>>>> values from H<n> are incorrect for D<n> proving that D<n> is
>>>>>>> isomorphic to a self-contradictory question for every H<n>.
>>>>>>>
>>>>>>
>>>>>> No, because a given H<n> can only give one result,
>>>>> Some of the elements of H<n>/D<n> are identical except for the return
>>>>> value from H. In both of these cases the return value is incorrect.
>>>>
>>>> Nope, can't be.
>>>
>>> The only difference between otherwise identical pairs of pairs H<n>/D<n>
>>> and H<m>/D<m> is the single integer values of 0/1 within H<n> and H<m>
>>> respectively thus proving that both True and False are the wrong return
>>> value for the identical finite string pairs D<n>/D<m>.
>>>
>>>
>>
>> So they are different programs. Different is different. Almost the
>> same is not the same.
>>
>> Unless you are claiming that 1 is the same as 0, they are different.
>>
>> So, your claim is based on a LIE, or you are admitting you are insane.
>
> >
>
> The key difference with my work that is a true innovation in this field
> is that H specifically recognizes self-contradictory inputs and rejects
> them.
>
> *Termination Analyzer H prevents Denial of Service attacks*
> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>
>

On 6/18/2023 9:38 PM, Richard Damon wrote:
> On 6/18/23 9:43 PM, olcott wrote:
>> On 6/18/2023 8:29 PM, Richard Damon wrote:
>>> On 6/18/23 8:59 PM, olcott wrote:
>>>> On 6/18/2023 7:01 PM, Richard Damon wrote:
>>>>> On 6/18/23 7:41 PM, olcott wrote:
>>>>>> On 6/18/2023 1:56 PM, Fritz Feldhase wrote:
>>>>>>> On Sunday, June 18, 2023 at 8:09:51 PM UTC+2, olcott wrote
>>>>>>> <nonsense>
>>>>>>>
>>>>>>> A possible "practical solution" for an actual "halt decider"
>>>>>>> might be something I will call a semi-halt-decider here.
>>>>>>>
>>>>>>> The latter allows for 3 answers (return values) when called:
>>>>>>>
>>>>>>> H(P, d) -> 1 "P(d) halts"
>>>>>>> H(P, d) -> -1 "P(d) doesn't halt."
>>>>>>> H(P, d) -> 0 "Don't know/can't tell if P(d) halts or not"
>>>>>>>
>>>>>>> Such a semi-halt-decider might be able to determine _the correct_
>>>>>>> answer (1, -1) for a big class of casses. On the other hand, it
>>>>>>> would always have the possibility to "give up" (for certain
>>>>>>> cases) and anwer with 0: "Don't know/can't tell" (and this way be
>>>>>>> able to avoid INCORRECT ANSWERS concerning the actual behavior of
>>>>>>> P(d)).
>>>>>>>
>>>>>>
>>>>>> The key difference with my work that is a true innovation in this
>>>>>> field
>>>>>> is that H doesn't simply give up. H specifically recognizes self-
>>>>>> contradictory inputs and rejects them.
>>>>>>
>>>>>> *Termination Analyzer H prevents Denial of Service attacks*
>>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>>>>>
>>>>>
>>>>>
>>>>> Except the input isn't self-contradictory, since the input can't
>>>>> exist until H is defined, and once H is defined, the input has
>>>>> definite behavior, so there is no self-contradiction possilble,
>>>>> only error.
>>>> If I ask you what correct (yes or no) answer of could Jack reply with?
>>>> Exactly why can’t you answer this?
>>>
>>> He has no answer that is correct, but that doesn't matter and is just
>>> you faliing into the fallacy of the Red Herring.
>>>
>> // The following is written in C
>> //
>> 01 typedef int (*ptr)(); // pointer to int function
>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>> 03
>> 04 int D(ptr x)
>> 05 {
>> 06   int Halt_Status = H(x, x);
>> 07   if (Halt_Status)
>> 08     HERE: goto HERE;
>> 09   return Halt_Status;
>> 10 }
>> 11
>> 12 void main()
>> 13 {
>> 14   H(D,D);
>> 15 }
>>
>> Since the above H is an unspecified wildcard you are free to encode it
>> in any one of an infinite number of different ways and return any
>> Boolean value that you want.
>
> Nope, D isn't a PROGRAM until H is DEFINED.
That is why I triple dog dare you to define it or acknowledge that no
such program can possibly be defined because the input D to any
corresponding H is isomorphic to Jack's question posed to Jack.

Once we acknowledge that the halting problem input to H is an incorrect
to H then we can understand that this incorrect question is aptly re-
framed into the correct question:

Does input D halt on its input [GOOD INPUT] or is D [BAD INPUT] that
either fails to halt or defines a pathological relationship to H.

This does overcome Rice's theorem for at least the reduction of Rice's
theorem to the halting problem.

Does input D have semantic property S or is input D [BAD 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/18/23 11:31 PM, olcott wrote:
> On 6/18/2023 9:38 PM, Richard Damon wrote:
>> On 6/18/23 9:43 PM, olcott wrote:
>>> On 6/18/2023 8:29 PM, Richard Damon wrote:
>>>> On 6/18/23 8:59 PM, olcott wrote:
>>>>> On 6/18/2023 7:01 PM, Richard Damon wrote:
>>>>>> On 6/18/23 7:41 PM, olcott wrote:
>>>>>>> On 6/18/2023 1:56 PM, Fritz Feldhase wrote:
>>>>>>>> On Sunday, June 18, 2023 at 8:09:51 PM UTC+2, olcott wrote
>>>>>>>> <nonsense>
>>>>>>>>
>>>>>>>> A possible "practical solution" for an actual "halt decider"
>>>>>>>> might be something I will call a semi-halt-decider here.
>>>>>>>>
>>>>>>>> The latter allows for 3 answers (return values) when called:
>>>>>>>>
>>>>>>>> H(P, d) -> 1 "P(d) halts"
>>>>>>>> H(P, d) -> -1 "P(d) doesn't halt."
>>>>>>>> H(P, d) -> 0 "Don't know/can't tell if P(d) halts or not"
>>>>>>>>
>>>>>>>> Such a semi-halt-decider might be able to determine _the
>>>>>>>> correct_ answer (1, -1) for a big class of casses. On the other
>>>>>>>> hand, it would always have the possibility to "give up" (for
>>>>>>>> certain cases) and anwer with 0: "Don't know/can't tell" (and
>>>>>>>> this way be able to avoid INCORRECT ANSWERS concerning the
>>>>>>>> actual behavior of P(d)).
>>>>>>>>
>>>>>>>
>>>>>>> The key difference with my work that is a true innovation in this
>>>>>>> field
>>>>>>> is that H doesn't simply give up. H specifically recognizes self-
>>>>>>> contradictory inputs and rejects them.
>>>>>>>
>>>>>>> *Termination Analyzer H prevents Denial of Service attacks*
>>>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>>>>>>
>>>>>>
>>>>>>
>>>>>> Except the input isn't self-contradictory, since the input can't
>>>>>> exist until H is defined, and once H is defined, the input has
>>>>>> definite behavior, so there is no self-contradiction possilble,
>>>>>> only error.
>>>>> If I ask you what correct (yes or no) answer of could Jack reply with?
>>>>> Exactly why can’t you answer this?
>>>>
>>>> He has no answer that is correct, but that doesn't matter and is
>>>> just you faliing into the fallacy of the Red Herring.
>>>>
>>> // The following is written in C
>>> //
>>> 01 typedef int (*ptr)(); // pointer to int function
>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>> 03
>>> 04 int D(ptr x)
>>> 05 {
>>> 06   int Halt_Status = H(x, x);
>>> 07   if (Halt_Status)
>>> 08     HERE: goto HERE;
>>> 09   return Halt_Status;
>>> 10 }
>>> 11
>>> 12 void main()
>>> 13 {
>>> 14   H(D,D);
>>> 15 }
>>>
>>> Since the above H is an unspecified wildcard you are free to encode it
>>> in any one of an infinite number of different ways and return any
>>> Boolean value that you want.
>>
>> Nope, D isn't a PROGRAM until H is DEFINED.
> That is why I triple dog dare you to define it or acknowledge that no
> such program can possibly be defined because the input D to any
> corresponding H is isomorphic to Jack's question posed to Jack.

SO, you AGREE that a "Correct Halt Decider", as defined by the Halting
Problem, can't exist.

It is easy to make D a program, just define some H, any H, then D is a
valid program, and will either Halt or not. D's validity as a program is
NOT dependent on H getting the right answer. Thus an H that just
immediately returns 0 makes D a valid program.

>
> Once we acknowledge that the halting problem input to H is an incorrect
> to H then we can understand that this incorrect question is aptly re-
> framed into the correct question:

Why is it "Incorrect"? The fact that H can't give the right answer is a
problem with H, not with the input.

The definition of a "Valid Input" for H, is that it represents a Program
and its input. This call sequence does that, so the input is valid.

>
> Does input D halt on its input [GOOD INPUT] or is D [BAD INPUT] that
> either fails to halt or defines a pathological relationship to H.

And D DOES halt on its input, since it will "call" H(D,D), which your H
has been defined so that it will return 0 from that call.

There is nothing "BAD" about a D that doesn't halt, that just means it
is an input that H needs to "reject" (return the "Non-Halting" value
for). There is also nothing "Bad" about the "pathological" relationship
between D and H, as that is just part of "Any Program".

Remember, if you change H to be the Hn, non-aborting version of it, and
the make the Dn from that Hn, we find that Dn(Dn) will not halt, so Hn
should have returned 0, but it just never returns an answer, showing
that *H* is a defective machine, not meeting its requirements.

>
> This does overcome Rice's theorem for at least the reduction of Rice's
> theorem to the halting problem.
>
> Does input D have semantic property S or is input D [BAD INPUT]?
>

No, because Rice's theorem is does the input have Semantic Property S,
and a "pathological relationship" isn't considered a "BAD INPUT".

ALL PROGRAMS means ALL PROGRAMS, not all the ones I can handle.

IF you wnat to try to define a Semntic Property S that somehow includes
this pathology in its criteria, you need to FORMALLY define what you
mean by it. You also need to show that the property is still wholly
Semantic, and that you haven't given yourself a Syntactic property.

You also then need to show that you can get the correct answer for ALL
inputs, the Achilies Heel for a Halt Decider might not be the Achilies
Heel for your new decider, so just because you handle it, doesn't mean
you have PROVEN that you can answwer that property.

On 6/19/2023 6:38 AM, Richard Damon wrote:
> On 6/18/23 11:31 PM, olcott wrote:
>> On 6/18/2023 9:38 PM, Richard Damon wrote:
>>> On 6/18/23 9:43 PM, olcott wrote:
>>>> On 6/18/2023 8:29 PM, Richard Damon wrote:
>>>>> On 6/18/23 8:59 PM, olcott wrote:
>>>>>> On 6/18/2023 7:01 PM, Richard Damon wrote:
>>>>>>> On 6/18/23 7:41 PM, olcott wrote:
>>>>>>>> On 6/18/2023 1:56 PM, Fritz Feldhase wrote:
>>>>>>>>> On Sunday, June 18, 2023 at 8:09:51 PM UTC+2, olcott wrote
>>>>>>>>> <nonsense>
>>>>>>>>>
>>>>>>>>> A possible "practical solution" for an actual "halt decider"
>>>>>>>>> might be something I will call a semi-halt-decider here.
>>>>>>>>>
>>>>>>>>> The latter allows for 3 answers (return values) when called:
>>>>>>>>>
>>>>>>>>> H(P, d) -> 1 "P(d) halts"
>>>>>>>>> H(P, d) -> -1 "P(d) doesn't halt."
>>>>>>>>> H(P, d) -> 0 "Don't know/can't tell if P(d) halts or not"
>>>>>>>>>
>>>>>>>>> Such a semi-halt-decider might be able to determine _the
>>>>>>>>> correct_ answer (1, -1) for a big class of casses. On the other
>>>>>>>>> hand, it would always have the possibility to "give up" (for
>>>>>>>>> certain cases) and anwer with 0: "Don't know/can't tell" (and
>>>>>>>>> this way be able to avoid INCORRECT ANSWERS concerning the
>>>>>>>>> actual behavior of P(d)).
>>>>>>>>>
>>>>>>>>
>>>>>>>> The key difference with my work that is a true innovation in
>>>>>>>> this field
>>>>>>>> is that H doesn't simply give up. H specifically recognizes self-
>>>>>>>> contradictory inputs and rejects them.
>>>>>>>>
>>>>>>>> *Termination Analyzer H prevents Denial of Service attacks*
>>>>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Except the input isn't self-contradictory, since the input can't
>>>>>>> exist until H is defined, and once H is defined, the input has
>>>>>>> definite behavior, so there is no self-contradiction possilble,
>>>>>>> only error.
>>>>>> If I ask you what correct (yes or no) answer of could Jack reply
>>>>>> with?
>>>>>> Exactly why can’t you answer this?
>>>>>
>>>>> He has no answer that is correct, but that doesn't matter and is
>>>>> just you faliing into the fallacy of the Red Herring.
>>>>>
>>>> // The following is written in C
>>>> //
>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>> 03
>>>> 04 int D(ptr x)
>>>> 05 {
>>>> 06   int Halt_Status = H(x, x);
>>>> 07   if (Halt_Status)
>>>> 08     HERE: goto HERE;
>>>> 09   return Halt_Status;
>>>> 10 }
>>>> 11
>>>> 12 void main()
>>>> 13 {
>>>> 14   H(D,D);
>>>> 15 }
>>>>
>>>> Since the above H is an unspecified wildcard you are free to encode it
>>>> in any one of an infinite number of different ways and return any
>>>> Boolean value that you want.
>>>
>>> Nope, D isn't a PROGRAM until H is DEFINED.
>> That is why I triple dog dare you to define it or acknowledge that no
>> such program can possibly be defined because the input D to any
>> corresponding H is isomorphic to Jack's question posed to Jack.
>
> SO, you AGREE that a "Correct Halt Decider", as defined by the Halting
> Problem, can't exist.
>

I don't agree that your understanding of the halting problem is correct.
H is required to report on the actual behavior that it actually sees.

You and others are requiring H to report on behavior that it does not
see. You already also admitted that when H reports on this behavior that
it does not see that this changes this behavior that it does not see
making its report incorrect.

Within the false hypothesis that H is incorrect to report that its input
does not halt, the only alternative is to change the meaning of what H
reports. When H becomes a [BAD INPUT] decider no one can correctly say
that H is wrong. This also refutes Rice which is more important that
solving the halting problem because it has a much broader scope.

Termination Analyzer H determines the semantic property of
[GOOD INPUT] meaning that input D halts <and>

[BAD INPUT] meaning
(a) input D doesn't halt <or>
(b) D has a pathological relationship to H. This means that D calls H
and does the opposite of the Boolean value that H returns.

> It is easy to make D a program, just define some H, any H, then D is a
> valid program, and will either Halt or not. D's validity as a program is
> NOT dependent on H getting the right answer. Thus an H that just
> immediately returns 0 makes D a valid program.
>

H correctly determines that D has the semantic property of [BAD INPUT]
making Denial of Service (DoS) attack detector H correct to reject D.

>>
>> Once we acknowledge that the halting problem input to H is an incorrect
>> to H then we can understand that this incorrect question is aptly re-
>> framed into the correct question:
>
> Why is it "Incorrect"? The fact that H can't give the right answer is a
> problem with H, not with the input.
>

Then the problem with Jack's question is Jack not the fact that Jack's
question is self-contradictory for Jack. Jack is simply too stupid to
give a correct yes or no answer to a self-contradictory question. We all
know that Jack's question has a correct answer, yet Jack is simply too
stupid to decide between yes and no.

> The definition of a "Valid Input" for H, is that it represents a Program
> and its input. This call sequence does that, so the input is valid.
>

A syntactically valid input is not the same as a semantically valid
input. Any input that makes both Boolean return values the wrong answer
is a semantically invalid input.

>>
>> Does input D halt on its input [GOOD INPUT] or is D [BAD INPUT] that
>> either fails to halt or defines a pathological relationship to H.
>
> And D DOES halt on its input, since it will "call" H(D,D), which your H
> has been defined so that it will return 0 from that call.
>

Which is a correct return value for the semantic property of [BAD INPUT].

> There is nothing "BAD" about a D that doesn't halt,

Sure everyone knows that Denial of Service attacks are great. My
hospital loved it when they had no access to patient records for several
days.

> that just means it
> is an input that H needs to "reject" (return the "Non-Halting" value
> for). There is also nothing "Bad" about the "pathological" relationship
> between D and H, as that is just part of "Any Program".
>

Yes that is true everyone loves successful Denial of Service attacks.
If there was a DoS detector that could correctly reject every
[malevolent input] people would really hate that. They love successful
DoS attacks.

> Remember, if you change H to be the Hn, non-aborting version of it, and
> the make the Dn from that Hn, we find that Dn(Dn) will not halt, so Hn
> should have returned 0, but it just never returns an answer, showing
> that *H* is a defective machine, not meeting its requirements.
>

When H reports on the semantic property of [BAD INPUT] the labels could
be switched to account for all of the people that love successful Denial
of Service attacks. Only inputs that allow DoS attacks are construed as
[GOOD INPUTS]. Inputs that simply halt are now called [BAD INPUTS].

H still correctly decides a semantic property of D, thus H still refutes
Rice.

>>
>> This does overcome Rice's theorem for at least the reduction of Rice's
>> theorem to the halting problem.
>>
>> Does input D have semantic property S or is input D [BAD INPUT]?
>>
>
> No, because Rice's theorem is does the input have Semantic Property S,
> and a "pathological relationship" isn't considered a "BAD INPUT".
>

On 6/19/23 10:30 AM, olcott wrote:
> On 6/19/2023 6:38 AM, Richard Damon wrote:
>> On 6/18/23 11:31 PM, olcott wrote:
>>> On 6/18/2023 9:38 PM, Richard Damon wrote:
>>>> On 6/18/23 9:43 PM, olcott wrote:
>>>>> On 6/18/2023 8:29 PM, Richard Damon wrote:
>>>>>> On 6/18/23 8:59 PM, olcott wrote:
>>>>>>> On 6/18/2023 7:01 PM, Richard Damon wrote:
>>>>>>>> On 6/18/23 7:41 PM, olcott wrote:
>>>>>>>>> On 6/18/2023 1:56 PM, Fritz Feldhase wrote:
>>>>>>>>>> On Sunday, June 18, 2023 at 8:09:51 PM UTC+2, olcott wrote
>>>>>>>>>> <nonsense>
>>>>>>>>>>
>>>>>>>>>> A possible "practical solution" for an actual "halt decider"
>>>>>>>>>> might be something I will call a semi-halt-decider here.
>>>>>>>>>>
>>>>>>>>>> The latter allows for 3 answers (return values) when called:
>>>>>>>>>>
>>>>>>>>>> H(P, d) -> 1 "P(d) halts"
>>>>>>>>>> H(P, d) -> -1 "P(d) doesn't halt."
>>>>>>>>>> H(P, d) -> 0 "Don't know/can't tell if P(d) halts or not"
>>>>>>>>>>
>>>>>>>>>> Such a semi-halt-decider might be able to determine _the
>>>>>>>>>> correct_ answer (1, -1) for a big class of casses. On the
>>>>>>>>>> other hand, it would always have the possibility to "give up"
>>>>>>>>>> (for certain cases) and anwer with 0: "Don't know/can't tell"
>>>>>>>>>> (and this way be able to avoid INCORRECT ANSWERS concerning
>>>>>>>>>> the actual behavior of P(d)).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The key difference with my work that is a true innovation in
>>>>>>>>> this field
>>>>>>>>> is that H doesn't simply give up. H specifically recognizes self-
>>>>>>>>> contradictory inputs and rejects them.
>>>>>>>>>
>>>>>>>>> *Termination Analyzer H prevents Denial of Service attacks*
>>>>>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Except the input isn't self-contradictory, since the input can't
>>>>>>>> exist until H is defined, and once H is defined, the input has
>>>>>>>> definite behavior, so there is no self-contradiction possilble,
>>>>>>>> only error.
>>>>>>> If I ask you what correct (yes or no) answer of could Jack reply
>>>>>>> with?
>>>>>>> Exactly why can’t you answer this?
>>>>>>
>>>>>> He has no answer that is correct, but that doesn't matter and is
>>>>>> just you faliing into the fallacy of the Red Herring.
>>>>>>
>>>>> // The following is written in C
>>>>> //
>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>>> 03
>>>>> 04 int D(ptr x)
>>>>> 05 {
>>>>> 06   int Halt_Status = H(x, x);
>>>>> 07   if (Halt_Status)
>>>>> 08     HERE: goto HERE;
>>>>> 09   return Halt_Status;
>>>>> 10 }
>>>>> 11
>>>>> 12 void main()
>>>>> 13 {
>>>>> 14   H(D,D);
>>>>> 15 }
>>>>>
>>>>> Since the above H is an unspecified wildcard you are free to encode it
>>>>> in any one of an infinite number of different ways and return any
>>>>> Boolean value that you want.
>>>>
>>>> Nope, D isn't a PROGRAM until H is DEFINED.
>>> That is why I triple dog dare you to define it or acknowledge that no
>>> such program can possibly be defined because the input D to any
>>> corresponding H is isomorphic to Jack's question posed to Jack.
>>
>> SO, you AGREE that a "Correct Halt Decider", as defined by the Halting
>> Problem, can't exist.
>>
>
> I don't agree that your understanding of the halting problem is correct.
> H is required to report on the actual behavior that it actually sees.

Where does THAT come from. It may only be ABLE to do so, but the
REQUIREMENT is the behavior of the actual machine.

You seem to have trouble with the English Languge.

Please show me any reputable reference that says you get to disregard
the ACTUAL REQUIREMENTS because you can't see what you need to do so

>
> You and others are requiring H to report on behavior that it does not
> see. You already also admitted that when H reports on this behavior that
> it does not see that this changes this behavior that it does not see
> making its report incorrect.

Yes, because that is what the requirements say. The requirements are
what the requirements say, because that is the requirements needed to
solve the mathematical problems that a Halt Decider is hoped to be able
to help with.

>
> Within the false hypothesis that H is incorrect to report that its input
> does not halt, the only alternative is to change the meaning of what H
> reports. When H becomes a [BAD INPUT] decider no one can correctly say
> that H is wrong. This also refutes Rice which is more important that
> solving the halting problem because it has a much broader scope.

That isn't a "false hypothesis", it is a stated requirement.

Since D(D) Halts, by the definition of the problem, H, to be correct,
must report Halting.

Remember:
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run forever.

Thus the thing to look at is the PROGRAM itself and its behavior.
DEFINITION.

>
> Termination Analyzer H determines the semantic property of
> [GOOD INPUT] meaning that input D halts <and>

Since the machine represented by the input does Halt, that condition is
statisfied.

Note you bad terminology, "Inputs" are just data, and don't actually DO
anything. They can have "syntactic properties", but not "Behavior". They
can represent something that does have behavior, and from the definiton
above, that is the machine they represent, NOT H's (partial) simulation
of them.

>
> [BAD INPUT] meaning
> (a) input D doesn't halt <or>
> (b) D has a pathological relationship to H. This means that D calls H
> and does the opposite of the Boolean value that H returns.

Which your H never atually confirms. You H will also call an HH that
does what H says to be pathological too, so you fail at this side.

>
>> It is easy to make D a program, just define some H, any H, then D is a
>> valid program, and will either Halt or not. D's validity as a program
>> is NOT dependent on H getting the right answer. Thus an H that just
>> immediately returns 0 makes D a valid program.
>>
>
> H correctly determines that D has the semantic property of [BAD INPUT]
> making Denial of Service (DoS) attack detector H correct to reject D.

Which isn't a criterial for a Halt Decider, and as I just explained
above, you don't actually detect the pathological relationship, just
that D calls H.

>
>
>>>
>>> Once we acknowledge that the halting problem input to H is an incorrect
>>> to H then we can understand that this incorrect question is aptly re-
>>> framed into the correct question:
>>
>> Why is it "Incorrect"? The fact that H can't give the right answer is
>> a problem with H, not with the input.
>>
>
> Then the problem with Jack's question is Jack not the fact that Jack's
> question is self-contradictory for Jack. Jack is simply too stupid to
> give a correct yes or no answer to a self-contradictory question. We all
> know that Jack's question has a correct answer, yet Jack is simply too
> stupid to decide between yes and no.

On 6/19/2023 7:45 PM, Richard Damon wrote:
> On 6/19/23 10:30 AM, olcott wrote:
>> On 6/19/2023 6:38 AM, Richard Damon wrote:
>>> On 6/18/23 11:31 PM, olcott wrote:
>>>> On 6/18/2023 9:38 PM, Richard Damon wrote:
>>>>> On 6/18/23 9:43 PM, olcott wrote:
>>>>>> On 6/18/2023 8:29 PM, Richard Damon wrote:
>>>>>>> On 6/18/23 8:59 PM, olcott wrote:
>>>>>>>> On 6/18/2023 7:01 PM, Richard Damon wrote:
>>>>>>>>> On 6/18/23 7:41 PM, olcott wrote:
>>>>>>>>>> On 6/18/2023 1:56 PM, Fritz Feldhase wrote:
>>>>>>>>>>> On Sunday, June 18, 2023 at 8:09:51 PM UTC+2, olcott wrote
>>>>>>>>>>> <nonsense>
>>>>>>>>>>>
>>>>>>>>>>> A possible "practical solution" for an actual "halt decider"
>>>>>>>>>>> might be something I will call a semi-halt-decider here.
>>>>>>>>>>>
>>>>>>>>>>> The latter allows for 3 answers (return values) when called:
>>>>>>>>>>>
>>>>>>>>>>> H(P, d) -> 1 "P(d) halts"
>>>>>>>>>>> H(P, d) -> -1 "P(d) doesn't halt."
>>>>>>>>>>> H(P, d) -> 0 "Don't know/can't tell if P(d) halts or not"
>>>>>>>>>>>
>>>>>>>>>>> Such a semi-halt-decider might be able to determine _the
>>>>>>>>>>> correct_ answer (1, -1) for a big class of casses. On the
>>>>>>>>>>> other hand, it would always have the possibility to "give up"
>>>>>>>>>>> (for certain cases) and anwer with 0: "Don't know/can't tell"
>>>>>>>>>>> (and this way be able to avoid INCORRECT ANSWERS concerning
>>>>>>>>>>> the actual behavior of P(d)).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The key difference with my work that is a true innovation in
>>>>>>>>>> this field
>>>>>>>>>> is that H doesn't simply give up. H specifically recognizes self-
>>>>>>>>>> contradictory inputs and rejects them.
>>>>>>>>>>
>>>>>>>>>> *Termination Analyzer H prevents Denial of Service attacks*
>>>>>>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except the input isn't self-contradictory, since the input
>>>>>>>>> can't exist until H is defined, and once H is defined, the
>>>>>>>>> input has definite behavior, so there is no self-contradiction
>>>>>>>>> possilble, only error.
>>>>>>>> If I ask you what correct (yes or no) answer of could Jack reply
>>>>>>>> with?
>>>>>>>> Exactly why can’t you answer this?
>>>>>>>
>>>>>>> He has no answer that is correct, but that doesn't matter and is
>>>>>>> just you faliing into the fallacy of the Red Herring.
>>>>>>>
>>>>>> // The following is written in C
>>>>>> //
>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>>>> 03
>>>>>> 04 int D(ptr x)
>>>>>> 05 {
>>>>>> 06   int Halt_Status = H(x, x);
>>>>>> 07   if (Halt_Status)
>>>>>> 08     HERE: goto HERE;
>>>>>> 09   return Halt_Status;
>>>>>> 10 }
>>>>>> 11
>>>>>> 12 void main()
>>>>>> 13 {
>>>>>> 14   H(D,D);
>>>>>> 15 }
>>>>>>
>>>>>> Since the above H is an unspecified wildcard you are free to
>>>>>> encode it
>>>>>> in any one of an infinite number of different ways and return any
>>>>>> Boolean value that you want.
>>>>>
>>>>> Nope, D isn't a PROGRAM until H is DEFINED.
>>>> That is why I triple dog dare you to define it or acknowledge that no
>>>> such program can possibly be defined because the input D to any
>>>> corresponding H is isomorphic to Jack's question posed to Jack.
>>>
>>> SO, you AGREE that a "Correct Halt Decider", as defined by the
>>> Halting Problem, can't exist.
>>>
>>
>> I don't agree that your understanding of the halting problem is correct.
>> H is required to report on the actual behavior that it actually sees.
>
> Where does THAT come from. It may only be ABLE to do so, but the
> REQUIREMENT is the behavior of the actual machine.
>
> You seem to have trouble with the English Languge.
>
> Please show me any reputable reference that says you get to disregard
> the ACTUAL REQUIREMENTS because you can't see what you need to do so
>
>>
>> You and others are requiring H to report on behavior that it does not
>> see. You already also admitted that when H reports on this behavior that
>> it does not see that this changes this behavior that it does not see
>> making its report incorrect.
>
> Yes, because that is what the requirements say. The requirements are
> what the requirements say, because that is the requirements needed to
> solve the mathematical problems that a Halt Decider is hoped to be able
> to help with.
>

When the requirements are self-contradictory then they are incorrect.

>>
>> Within the false hypothesis that H is incorrect to report that its input
>> does not halt, the only alternative is to change the meaning of what H
>> reports. When H becomes a [BAD INPUT] decider no one can correctly say
>> that H is wrong. This also refutes Rice which is more important that
>> solving the halting problem because it has a much broader scope.
>
> That isn't a "false hypothesis", it is a stated requirement.
>
> Since D(D) Halts, by the definition of the problem, H, to be correct,
> must report Halting.
>
> Remember:
> In computability theory, the halting problem is the problem of
> determining, from a description of an arbitrary computer program and an
> input, whether the program will finish running, or continue to run forever.
>
> Thus the thing to look at is the PROGRAM itself and its behavior.
> DEFINITION.
>

When the requirements are self-contradictory then they are incorrect.
When the bible says that God <is> and God <has> wrath the bible lies.

>>
>> Termination Analyzer H determines the semantic property of
>> [GOOD INPUT] meaning that input D halts <and>
>
> Since the machine represented by the input does Halt, that condition is
> statisfied.
>
> Note you bad terminology, "Inputs" are just data, and don't actually DO
> anything. They can have "syntactic properties", but not "Behavior". They
> can represent something that does have behavior, and from the definiton
> above, that is the machine they represent, NOT H's (partial) simulation
> of them.
>

Simply ignoring that a question is self-contradictory doesn't make it
not self-contradictory.

>>
>> [BAD INPUT] meaning
>> (a) input D doesn't halt <or>
>> (b) D has a pathological relationship to H. This means that D calls H
>> and does the opposite of the Boolean value that H returns.
>
> Which your H never atually confirms. You H will also call an HH that
> does what H says to be pathological too, so you fail at this side.
>
>>
>>> It is easy to make D a program, just define some H, any H, then D is
>>> a valid program, and will either Halt or not. D's validity as a
>>> program is NOT dependent on H getting the right answer. Thus an H
>>> that just immediately returns 0 makes D a valid program.
>>>
>>
>> H correctly determines that D has the semantic property of [BAD INPUT]
>> making Denial of Service (DoS) attack detector H correct to reject D.
>
> Which isn't a criterial for a Halt Decider, and as I just explained
> above, you don't actually detect the pathological relationship, just
> that D calls H.
>

On Monday, June 19, 2023 at 10:57:39 PM UTC-5, olcott wrote:
> On 6/19/2023 7:45 PM, Richard Damon wrote:
> > On 6/19/23 10:30 AM, olcott wrote:
> >> On 6/19/2023 6:38 AM, Richard Damon wrote:
> >>> On 6/18/23 11:31 PM, olcott wrote:
> >>>> On 6/18/2023 9:38 PM, Richard Damon wrote:
> >>>>> On 6/18/23 9:43 PM, olcott wrote:
> >>>>>> On 6/18/2023 8:29 PM, Richard Damon wrote:
> >>>>>>> On 6/18/23 8:59 PM, olcott wrote:
> >>>>>>>> On 6/18/2023 7:01 PM, Richard Damon wrote:
> >>>>>>>>> On 6/18/23 7:41 PM, olcott wrote:
> >>>>>>>>>> On 6/18/2023 1:56 PM, Fritz Feldhase wrote:
> >>>>>>>>>>> On Sunday, June 18, 2023 at 8:09:51 PM UTC+2, olcott wrote
> >>>>>>>>>>> <nonsense>
> >>>>>>>>>>>
> >>>>>>>>>>> A possible "practical solution" for an actual "halt decider"
> >>>>>>>>>>> might be something I will call a semi-halt-decider here.
> >>>>>>>>>>>
> >>>>>>>>>>> The latter allows for 3 answers (return values) when called:
> >>>>>>>>>>>
> >>>>>>>>>>> H(P, d) -> 1 "P(d) halts"
> >>>>>>>>>>> H(P, d) -> -1 "P(d) doesn't halt."
> >>>>>>>>>>> H(P, d) -> 0 "Don't know/can't tell if P(d) halts or not"
> >>>>>>>>>>>
> >>>>>>>>>>> Such a semi-halt-decider might be able to determine _the
> >>>>>>>>>>> correct_ answer (1, -1) for a big class of casses. On the
> >>>>>>>>>>> other hand, it would always have the possibility to "give up"
> >>>>>>>>>>> (for certain cases) and anwer with 0: "Don't know/can't tell"
> >>>>>>>>>>> (and this way be able to avoid INCORRECT ANSWERS concerning
> >>>>>>>>>>> the actual behavior of P(d)).
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> The key difference with my work that is a true innovation in
> >>>>>>>>>> this field
> >>>>>>>>>> is that H doesn't simply give up. H specifically recognizes self-
> >>>>>>>>>> contradictory inputs and rejects them.
> >>>>>>>>>>
> >>>>>>>>>> *Termination Analyzer H prevents Denial of Service attacks*
> >>>>>>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> Except the input isn't self-contradictory, since the input
> >>>>>>>>> can't exist until H is defined, and once H is defined, the
> >>>>>>>>> input has definite behavior, so there is no self-contradiction
> >>>>>>>>> possilble, only error.
> >>>>>>>> If I ask you what correct (yes or no) answer of could Jack reply
> >>>>>>>> with?
> >>>>>>>> Exactly why can’t you answer this?
> >>>>>>>
> >>>>>>> He has no answer that is correct, but that doesn't matter and is
> >>>>>>> just you faliing into the fallacy of the Red Herring.
> >>>>>>>
> >>>>>> // The following is written in C
> >>>>>> //
> >>>>>> 01 typedef int (*ptr)(); // pointer to int function
> >>>>>> 02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
> >>>>>> 03
> >>>>>> 04 int D(ptr x)
> >>>>>> 05 {
> >>>>>> 06 int Halt_Status = H(x, x);
> >>>>>> 07 if (Halt_Status)
> >>>>>> 08 HERE: goto HERE;
> >>>>>> 09 return Halt_Status;
> >>>>>> 10 }
> >>>>>> 11
> >>>>>> 12 void main()
> >>>>>> 13 {
> >>>>>> 14 H(D,D);
> >>>>>> 15 }
> >>>>>>
> >>>>>> Since the above H is an unspecified wildcard you are free to
> >>>>>> encode it
> >>>>>> in any one of an infinite number of different ways and return any
> >>>>>> Boolean value that you want.
> >>>>>
> >>>>> Nope, D isn't a PROGRAM until H is DEFINED.
> >>>> That is why I triple dog dare you to define it or acknowledge that no
> >>>> such program can possibly be defined because the input D to any
> >>>> corresponding H is isomorphic to Jack's question posed to Jack.
> >>>
> >>> SO, you AGREE that a "Correct Halt Decider", as defined by the
> >>> Halting Problem, can't exist.
> >>>
> >>
> >> I don't agree that your understanding of the halting problem is correct.
> >> H is required to report on the actual behavior that it actually sees.
> >
> > Where does THAT come from. It may only be ABLE to do so, but the
> > REQUIREMENT is the behavior of the actual machine.
> >
> > You seem to have trouble with the English Languge.
> >
> > Please show me any reputable reference that says you get to disregard
> > the ACTUAL REQUIREMENTS because you can't see what you need to do so
> >
> >>
> >> You and others are requiring H to report on behavior that it does not
> >> see. You already also admitted that when H reports on this behavior that
> >> it does not see that this changes this behavior that it does not see
> >> making its report incorrect.
> >
> > Yes, because that is what the requirements say. The requirements are
> > what the requirements say, because that is the requirements needed to
> > solve the mathematical problems that a Halt Decider is hoped to be able
> > to help with.
> >
> When the requirements are self-contradictory then they are incorrect.
> >>
> >> Within the false hypothesis that H is incorrect to report that its input
> >> does not halt, the only alternative is to change the meaning of what H
> >> reports. When H becomes a [BAD INPUT] decider no one can correctly say
> >> that H is wrong. This also refutes Rice which is more important that
> >> solving the halting problem because it has a much broader scope.
> >
> > That isn't a "false hypothesis", it is a stated requirement.
> >
> > Since D(D) Halts, by the definition of the problem, H, to be correct,
> > must report Halting.
> >
> > Remember:
> > In computability theory, the halting problem is the problem of
> > determining, from a description of an arbitrary computer program and an
> > input, whether the program will finish running, or continue to run forever.
> >
> > Thus the thing to look at is the PROGRAM itself and its behavior.
> > DEFINITION.
> >
> When the requirements are self-contradictory then they are incorrect.
> When the bible says that God <is> and God <has> wrath the bible lies.
> >>
> >> Termination Analyzer H determines the semantic property of
> >> [GOOD INPUT] meaning that input D halts <and>
> >
> > Since the machine represented by the input does Halt, that condition is
> > statisfied.
> >
> > Note you bad terminology, "Inputs" are just data, and don't actually DO
> > anything. They can have "syntactic properties", but not "Behavior". They
> > can represent something that does have behavior, and from the definiton
> > above, that is the machine they represent, NOT H's (partial) simulation
> > of them.
> >
> Simply ignoring that a question is self-contradictory doesn't make it
> not self-contradictory.
> >>
> >> [BAD INPUT] meaning
> >> (a) input D doesn't halt <or>
> >> (b) D has a pathological relationship to H. This means that D calls H
> >> and does the opposite of the Boolean value that H returns.
> >
> > Which your H never atually confirms. You H will also call an HH that
> > does what H says to be pathological too, so you fail at this side.
> >
> >>
> >>> It is easy to make D a program, just define some H, any H, then D is
> >>> a valid program, and will either Halt or not. D's validity as a
> >>> program is NOT dependent on H getting the right answer. Thus an H
> >>> that just immediately returns 0 makes D a valid program.
> >>>
> >>
> >> H correctly determines that D has the semantic property of [BAD INPUT]
> >> making Denial of Service (DoS) attack detector H correct to reject D.
> >
> > Which isn't a criterial for a Halt Decider, and as I just explained
> > above, you don't actually detect the pathological relationship, just
> > that D calls H.
> >
> Instead it refutes Rice's theorem.
> >>
> >>
> >>>>
> >>>> Once we acknowledge that the halting problem input to H is an incorrect
> >>>> to H then we can understand that this incorrect question is aptly re-
> >>>> framed into the correct question:
> >>>
> >>> Why is it "Incorrect"? The fact that H can't give the right answer is
> >>> a problem with H, not with the input.
> >>>
> >>
> >> Then the problem with Jack's question is Jack not the fact that Jack's
> >> question is self-contradictory for Jack. Jack is simply too stupid to
> >> give a correct yes or no answer to a self-contradictory question. We all
> >> know that Jack's question has a correct answer, yet Jack is simply too
> >> stupid to decide between yes and no.
> >
> > The problem with "Jack's Question" is it asks about something that
> > doesn't have a correct answer NOW.
> >
> Sure it does you ask three people
> (a) Bill says Jack will say yes
> (b) John says that Jack will say no
> (c) Harry say Jack will say nothing or something besides yes or no
> One of them is right.
>
> Because our imaginary Jack is fictional Harry was right.
> >>
> >>> The definition of a "Valid Input" for H, is that it represents a
> >>> Program and its input. This call sequence does that, so the input is
> >>> valid.
> >>>
> >>
> >> A syntactically valid input is not the same as a semantically valid
> >> input. Any input that makes both Boolean return values the wrong answer
> >> is a semantically invalid input.
> >
> > Nope, it is a PROGRAM, thus it is VALID. If you try to define it as not
> > valid, you are just admitting that H isn't a "Halt Decider" by the
> > definition of Computation Theory.
> >
> Saying that it is valid because it is a program simply ignores bugs and
> indicates you know hardly anything about programming.
> > You clearly don't understand what you are talking about.
> >
> >>
> >>>>
> >>>> Does input D halt on its input [GOOD INPUT] or is D [BAD INPUT] that
> >>>> either fails to halt or defines a pathological relationship to H.
> >>>
> >>> And D DOES halt on its input, since it will "call" H(D,D), which your
> >>> H has been defined so that it will return 0 from that call.
> >>>
> >>
> >> Which is a correct return value for the semantic property of [BAD INPUT].
> >
> > But makes D(D) Halt, so it is the wrong answer for a Halt Decider.
> >
> Not at all 0 means halts or D does the opposite of whatever Boolean
> value that H returns.
> > You are just admitting that you have been lying about working on the
> > Halting Problem of Computation Theory, the one descibed by the Linz
> > paper you quote.
> >
> When I point out that the conventional halting problem is self
> contradictory this is the actual halting problem that I am referring to.
> > Fine, everything you have said thus becomes a LIE.
> >
> >>
> >>> There is nothing "BAD" about a D that doesn't halt,
> >>
> >> Sure everyone knows that Denial of Service attacks are great. My
> >> hospital loved it when they had no access to patient records for several
> >> days.
> >
> > Except the only DOS was to the Decider. If they just ran the program, it
> > would have ended just fine.
> >
> > You just don't understand the problem you are talking about and thus you
> > keep lying about it. You can't use the "honest mistake" excues, as the
> > errors have been pointed out, but you refuse to correct yourself.
> >
> >>
> >>> that just means it is an input that H needs to "reject" (return the
> >>> "Non-Halting" value for). There is also nothing "Bad" about the
> >>> "pathological" relationship between D and H, as that is just part of
> >>> "Any Program".
> >>>
> >>
> >> Yes that is true everyone loves successful Denial of Service attacks.
> >> If there was a DoS detector that could correctly reject every
> >> [malevolent input] people would really hate that. They love successful
> >> DoS attacks.
> >
> > But this isn't the DOS detector problem, that allows false positives.
> > This is the accurate Halt Decider problem, which H fails at.
> >
> > You are just admitting that you have been LYING for years about what you
> > are working on.
> >
> >>
> >>> Remember, if you change H to be the Hn, non-aborting version of it,
> >>> and the make the Dn from that Hn, we find that Dn(Dn) will not halt,
> >>> so Hn should have returned 0, but it just never returns an answer,
> >>> showing that *H* is a defective machine, not meeting its requirements..
> >>>
> >>
> >> When H reports on the semantic property of [BAD INPUT] the labels could
> >> be switched to account for all of the people that love successful Denial
> >> of Service attacks. Only inputs that allow DoS attacks are construed as
> >> [GOOD INPUTS]. Inputs that simply halt are now called [BAD INPUTS].
> >>
> >> H still correctly decides a semantic property of D, thus H still refutes
> >> Rice.
> >
> >
> > Nope. You can't refute Rice by saying that a machine gets one input right.
> >
> > FALLACY of proof by example
> >
> > You are just proving your logic system is full of fallacies.
> >
> >>
> >>>>
> >>>> This does overcome Rice's theorem for at least the reduction of Rice's
> >>>> theorem to the halting problem.
> >>>>
> >>>> Does input D have semantic property S or is input D [BAD INPUT]?
> >>>>
> >>>
> >>> No, because Rice's theorem is does the input have Semantic Property
> >>> S, and a "pathological relationship" isn't considered a "BAD INPUT".
> >>>
> >>
> >> That is the only reason that Rice has not been overcome. No one ever
> >> thought of a way to exclude [BAD INPUTS] thus making semantic properties
> >> undecidable. Once we do exclude [BAD INPUTS] then semantic properties
> >> are decidable.
> >
> > But you H doesn't successful decide on your property, as the DD that
> > does what H says is called "Bad input" when it doesn't meet the criteria
> > you have defined.
> >
> >>
> >>> ALL PROGRAMS means ALL PROGRAMS, not all the ones I can handle.
> >>>
> >>
> >> H correctly determines the semantic property of [BAD INPUT] prior to my
> >> work no H could ever correctly determine any semantic property. That H
> >> does correctly determine at least a single semantic property when Rice
> >> claims that no H can every determine any semantic property refutes Rice.
> >>
> >
> > Nope, H gets DD wrong.
> >
> >>> IF you wnat to try to define a Semntic Property S that somehow
> >>> includes this pathology in its criteria, you need to FORMALLY define
> >>> what you mean by it. You also need to show that the property is still
> >>> wholly Semantic, and that you haven't given yourself a Syntactic
> >>> property.
> >>>
> >>
> >> When-so-ever any input to any decider calls this decider with an input
> >> that does the opposite of whatever Boolean value that this decider
> >> returns this input <is> a pathological input. My H has been able to do
> >> that for more than two years.
> >
> > But it fails on DD, so it still fail.
> >
> >>
> >> My system also works with embedded copies of deciders yet this makes the
> >> code much more difficult to understand so I didn't implement it.
> >
> > I don't think it does. I think you don't understand the nature of that
> > problem.
> >
> >>
> >>> You also then need to show that you can get the correct answer for
> >>> ALL inputs, the Achilies Heel for a Halt Decider might not be the
> >>> Achilies Heel for your new decider, so just because you handle it,
> >>> doesn't mean you have PROVEN that you can answwer that property.
> >>
> >> H does correctly refute Rice's theorem for the halting problem's
> >> pathological input. This is much more success than anyone else has ever
> >> achieved. Once this success is acknowledged a well funded large team of
> >> experts can work on extending my ideas.
> >>
> >
> > Nope. Remember, by YOUR definiton of Pathological, your H fails for
> > DD(DD) as described above.
> --
> Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
> hits a target no one else can see." Arthur Schopenhauer

On Tue, 20 Jun 2023 00:33:57 -0700 (PDT), Don Stockbauer wrote:

>
> what's this chatGPT thing? I've never heard of it.

There's a LLM shell discussion over in comp.ai.shells...

ChatGPT and Bard, mostly.

c.a.shells added, fu2 set.

--
-v

On 6/19/23 11:57 PM, olcott wrote:
> On 6/19/2023 7:45 PM, Richard Damon wrote:
>> On 6/19/23 10:30 AM, olcott wrote:
>>> On 6/19/2023 6:38 AM, Richard Damon wrote:
>>>> On 6/18/23 11:31 PM, olcott wrote:
>>>>> On 6/18/2023 9:38 PM, Richard Damon wrote:
>>>>>> On 6/18/23 9:43 PM, olcott wrote:
>>>>>>> On 6/18/2023 8:29 PM, Richard Damon wrote:
>>>>>>>> On 6/18/23 8:59 PM, olcott wrote:
>>>>>>>>> On 6/18/2023 7:01 PM, Richard Damon wrote:
>>>>>>>>>> On 6/18/23 7:41 PM, olcott wrote:
>>>>>>>>>>> On 6/18/2023 1:56 PM, Fritz Feldhase wrote:
>>>>>>>>>>>> On Sunday, June 18, 2023 at 8:09:51 PM UTC+2, olcott wrote
>>>>>>>>>>>> <nonsense>
>>>>>>>>>>>>
>>>>>>>>>>>> A possible "practical solution" for an actual "halt decider"
>>>>>>>>>>>> might be something I will call a semi-halt-decider here.
>>>>>>>>>>>>
>>>>>>>>>>>> The latter allows for 3 answers (return values) when called:
>>>>>>>>>>>>
>>>>>>>>>>>> H(P, d) -> 1 "P(d) halts"
>>>>>>>>>>>> H(P, d) -> -1 "P(d) doesn't halt."
>>>>>>>>>>>> H(P, d) -> 0 "Don't know/can't tell if P(d) halts or not"
>>>>>>>>>>>>
>>>>>>>>>>>> Such a semi-halt-decider might be able to determine _the
>>>>>>>>>>>> correct_ answer (1, -1) for a big class of casses. On the
>>>>>>>>>>>> other hand, it would always have the possibility to "give
>>>>>>>>>>>> up" (for certain cases) and anwer with 0: "Don't know/can't
>>>>>>>>>>>> tell" (and this way be able to avoid INCORRECT ANSWERS
>>>>>>>>>>>> concerning the actual behavior of P(d)).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The key difference with my work that is a true innovation in
>>>>>>>>>>> this field
>>>>>>>>>>> is that H doesn't simply give up. H specifically recognizes
>>>>>>>>>>> self-
>>>>>>>>>>> contradictory inputs and rejects them.
>>>>>>>>>>>
>>>>>>>>>>> *Termination Analyzer H prevents Denial of Service attacks*
>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Except the input isn't self-contradictory, since the input
>>>>>>>>>> can't exist until H is defined, and once H is defined, the
>>>>>>>>>> input has definite behavior, so there is no self-contradiction
>>>>>>>>>> possilble, only error.
>>>>>>>>> If I ask you what correct (yes or no) answer of could Jack
>>>>>>>>> reply with?
>>>>>>>>> Exactly why can’t you answer this?
>>>>>>>>
>>>>>>>> He has no answer that is correct, but that doesn't matter and is
>>>>>>>> just you faliing into the fallacy of the Red Herring.
>>>>>>>>
>>>>>>> // The following is written in C
>>>>>>> //
>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>>>>> 03
>>>>>>> 04 int D(ptr x)
>>>>>>> 05 {
>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>> 07   if (Halt_Status)
>>>>>>> 08     HERE: goto HERE;
>>>>>>> 09   return Halt_Status;
>>>>>>> 10 }
>>>>>>> 11
>>>>>>> 12 void main()
>>>>>>> 13 {
>>>>>>> 14   H(D,D);
>>>>>>> 15 }
>>>>>>>
>>>>>>> Since the above H is an unspecified wildcard you are free to
>>>>>>> encode it
>>>>>>> in any one of an infinite number of different ways and return any
>>>>>>> Boolean value that you want.
>>>>>>
>>>>>> Nope, D isn't a PROGRAM until H is DEFINED.
>>>>> That is why I triple dog dare you to define it or acknowledge that no
>>>>> such program can possibly be defined because the input D to any
>>>>> corresponding H is isomorphic to Jack's question posed to Jack.
>>>>
>>>> SO, you AGREE that a "Correct Halt Decider", as defined by the
>>>> Halting Problem, can't exist.
>>>>
>>>
>>> I don't agree that your understanding of the halting problem is correct.
>>> H is required to report on the actual behavior that it actually sees.
>>
>> Where does THAT come from. It may only be ABLE to do so, but the
>> REQUIREMENT is the behavior of the actual machine.
>>
>> You seem to have trouble with the English Languge.
>>
>> Please show me any reputable reference that says you get to disregard
>> the ACTUAL REQUIREMENTS because you can't see what you need to do so
>>
>>>
>>> You and others are requiring H to report on behavior that it does not
>>> see. You already also admitted that when H reports on this behavior that
>>> it does not see that this changes this behavior that it does not see
>>> making its report incorrect.
>>
>> Yes, because that is what the requirements say. The requirements are
>> what the requirements say, because that is the requirements needed to
>> solve the mathematical problems that a Halt Decider is hoped to be
>> able to help with.
>>
>
> When the requirements are self-contradictory then they are incorrect.

Whats self-contradictory of the ACTUAL QUESTION that is asked?

Does the program represented by the input Halt?

Since the H you claim to be correct is the H that returns 0 when asked
H(D,D), it turns out the the program represented by that input, that is
D(D) does Halt. No contradiction in the actual question.

The contradiction you run into is in trying to design an H to be
correct, and THAT says that it is impossible to make such an H

>
>>>
>>> Within the false hypothesis that H is incorrect to report that its input
>>> does not halt, the only alternative is to change the meaning of what H
>>> reports. When H becomes a [BAD INPUT] decider no one can correctly say
>>> that H is wrong. This also refutes Rice which is more important that
>>> solving the halting problem because it has a much broader scope.
>>
>> That isn't a "false hypothesis", it is a stated requirement.
>>
>> Since D(D) Halts, by the definition of the problem, H, to be correct,
>> must report Halting.
>>
>> Remember:
>> In computability theory, the halting problem is the problem of
>> determining, from a description of an arbitrary computer program and
>> an input, whether the program will finish running, or continue to run
>> forever.
>>
>> Thus the thing to look at is the PROGRAM itself and its behavior.
>> DEFINITION.
>>
>
> When the requirements are self-contradictory then they are incorrect.
> When the bible says that God <is> and God <has> wrath the bible lies.

Again, where is the actual contradiction in the actual question asked.
You just don't understand English.

That goes for how you read the Bible, and I guess you will find out
about God's wrath when he decides your time is up.

>
>>>
>>> Termination Analyzer H determines the semantic property of
>>> [GOOD INPUT] meaning that input D halts <and>
>>
>> Since the machine represented by the input does Halt, that condition
>> is statisfied.
>>
>> Note you bad terminology, "Inputs" are just data, and don't actually
>> DO anything. They can have "syntactic properties", but not "Behavior".
>> They can represent something that does have behavior, and from the
>> definiton above, that is the machine they represent, NOT H's (partial)
>> simulation of them.
>>
>
> Simply ignoring that a question is self-contradictory doesn't make it
> not self-contradictory.

On 6/19/2023 3:08 PM, Ben Bacarisse wrote:
> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>
>> On Monday, June 19, 2023 at 5:58:39 PM UTC+2, olcott wrote:
>>
>>> the full semantics of the question <bla>
>>
>> Look, dumbo, we are asking the simple question: "Does D(D) halt?"
>>
>> Now, D(D) either halts or doesn't halt.
>>
>> Hence the CORRECT yes/no-answer to the question "Does D(D) halt?" is
>> "yes" iff D(D) halts and "no" if D(D) doesn't halt.
>
> Just a reminder that you are arguing with someone who has declared that
> the wrong answer is the right one:
>
> Me: "do you still assert that [...] false is the "correct" answer even
> though P(P) halts?"
>
> PO: Yes that is the correct answer even though P(P) halts.
>
> (Back then, D was called P.)
>
> This was not a slip of the tongue. He has been quite clear that he is
> talking about something other than what the world calls halting. It's
> about what /would/ happen if the program were slight different, not
> about what actually happens:
>
> PO: "A non-halting computation is every computation that never halts
> unless its simulation is aborted. This maps to every element of the
> conventional halting problem set of non-halting computations and a
> few more."
>
> He has been (eventually) perfectly clear -- PO's "Other Halting" is not
> halting, which is why false can be the correct answer for some halting
> computations. The only mystery is why anyone still wants to talk about
> POOH.
>

Stop doing this Ben !!!

When we use the criteria:
Can D correctly simulated by H ever terminate normally?

After N steps of correct simulation the execution trace of D proves that
D cannot possibly reach its final instruction and terminate normally in
any finite number of steps.

This criteria matches non-halting input and it also matches the cases
where the input D has been intentionally defined to do the opposite of
whatever Boolean value that H returns.

When H returns 1 it means that its input halts and when H return 0
it means that either its input does not halt or D was intentionally
defined to do the opposite of whatever Boolean value that H returns.

To the best of my knowledge no one has ever made this much progress on
the halting problem's pathological input. To the best of my knowledge
everyone else was completely stumped by the halting problem's
pathological 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/20/2023 6:19 AM, Richard Damon wrote:
> On 6/19/23 11:57 PM, olcott wrote:
>> On 6/19/2023 7:45 PM, Richard Damon wrote:
>>> On 6/19/23 10:30 AM, olcott wrote:
>>>> On 6/19/2023 6:38 AM, Richard Damon wrote:
>>>>> On 6/18/23 11:31 PM, olcott wrote:
>>>>>> On 6/18/2023 9:38 PM, Richard Damon wrote:
>>>>>>> On 6/18/23 9:43 PM, olcott wrote:
>>>>>>>> On 6/18/2023 8:29 PM, Richard Damon wrote:
>>>>>>>>> On 6/18/23 8:59 PM, olcott wrote:
>>>>>>>>>> On 6/18/2023 7:01 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/18/23 7:41 PM, olcott wrote:
>>>>>>>>>>>> On 6/18/2023 1:56 PM, Fritz Feldhase wrote:
>>>>>>>>>>>>> On Sunday, June 18, 2023 at 8:09:51 PM UTC+2, olcott wrote
>>>>>>>>>>>>> <nonsense>
>>>>>>>>>>>>>
>>>>>>>>>>>>> A possible "practical solution" for an actual "halt
>>>>>>>>>>>>> decider" might be something I will call a semi-halt-decider
>>>>>>>>>>>>> here.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The latter allows for 3 answers (return values) when called:
>>>>>>>>>>>>>
>>>>>>>>>>>>> H(P, d) -> 1 "P(d) halts"
>>>>>>>>>>>>> H(P, d) -> -1 "P(d) doesn't halt."
>>>>>>>>>>>>> H(P, d) -> 0 "Don't know/can't tell if P(d) halts or not"
>>>>>>>>>>>>>
>>>>>>>>>>>>> Such a semi-halt-decider might be able to determine _the
>>>>>>>>>>>>> correct_ answer (1, -1) for a big class of casses. On the
>>>>>>>>>>>>> other hand, it would always have the possibility to "give
>>>>>>>>>>>>> up" (for certain cases) and anwer with 0: "Don't know/can't
>>>>>>>>>>>>> tell" (and this way be able to avoid INCORRECT ANSWERS
>>>>>>>>>>>>> concerning the actual behavior of P(d)).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The key difference with my work that is a true innovation in
>>>>>>>>>>>> this field
>>>>>>>>>>>> is that H doesn't simply give up. H specifically recognizes
>>>>>>>>>>>> self-
>>>>>>>>>>>> contradictory inputs and rejects them.
>>>>>>>>>>>>
>>>>>>>>>>>> *Termination Analyzer H prevents Denial of Service attacks*
>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Except the input isn't self-contradictory, since the input
>>>>>>>>>>> can't exist until H is defined, and once H is defined, the
>>>>>>>>>>> input has definite behavior, so there is no
>>>>>>>>>>> self-contradiction possilble, only error.
>>>>>>>>>> If I ask you what correct (yes or no) answer of could Jack
>>>>>>>>>> reply with?
>>>>>>>>>> Exactly why can’t you answer this?
>>>>>>>>>
>>>>>>>>> He has no answer that is correct, but that doesn't matter and
>>>>>>>>> is just you faliing into the fallacy of the Red Herring.
>>>>>>>>>
>>>>>>>> // The following is written in C
>>>>>>>> //
>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>>>>>> 03
>>>>>>>> 04 int D(ptr x)
>>>>>>>> 05 {
>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>> 07   if (Halt_Status)
>>>>>>>> 08     HERE: goto HERE;
>>>>>>>> 09   return Halt_Status;
>>>>>>>> 10 }
>>>>>>>> 11
>>>>>>>> 12 void main()
>>>>>>>> 13 {
>>>>>>>> 14   H(D,D);
>>>>>>>> 15 }
>>>>>>>>
>>>>>>>> Since the above H is an unspecified wildcard you are free to
>>>>>>>> encode it
>>>>>>>> in any one of an infinite number of different ways and return any
>>>>>>>> Boolean value that you want.
>>>>>>>
>>>>>>> Nope, D isn't a PROGRAM until H is DEFINED.
>>>>>> That is why I triple dog dare you to define it or acknowledge that no
>>>>>> such program can possibly be defined because the input D to any
>>>>>> corresponding H is isomorphic to Jack's question posed to Jack.
>>>>>
>>>>> SO, you AGREE that a "Correct Halt Decider", as defined by the
>>>>> Halting Problem, can't exist.
>>>>>
>>>>
>>>> I don't agree that your understanding of the halting problem is
>>>> correct.
>>>> H is required to report on the actual behavior that it actually sees.
>>>
>>> Where does THAT come from. It may only be ABLE to do so, but the
>>> REQUIREMENT is the behavior of the actual machine.
>>>
>>> You seem to have trouble with the English Languge.
>>>
>>> Please show me any reputable reference that says you get to disregard
>>> the ACTUAL REQUIREMENTS because you can't see what you need to do so
>>>
>>>>
>>>> You and others are requiring H to report on behavior that it does not
>>>> see. You already also admitted that when H reports on this behavior
>>>> that
>>>> it does not see that this changes this behavior that it does not see
>>>> making its report incorrect.
>>>
>>> Yes, because that is what the requirements say. The requirements are
>>> what the requirements say, because that is the requirements needed to
>>> solve the mathematical problems that a Halt Decider is hoped to be
>>> able to help with.
>>>
>>
>> When the requirements are self-contradictory then they are incorrect.
>
> Whats self-contradictory of the ACTUAL QUESTION that is asked?
>

D was intentionally defined to do the opposite
of whatever Boolean value that H returns.

D was intentionally defined to do the opposite
of whatever Boolean value that H returns.

D was intentionally defined to do the opposite
of whatever Boolean value that H returns.

D was intentionally defined to do the opposite
of whatever Boolean value that H returns.

D was intentionally defined to do the opposite
of whatever Boolean value that H returns.

When we use the criteria:
Can D correctly simulated by H ever terminate normally?

After N steps of correct simulation the execution trace of D proves that
D cannot possibly reach its final instruction and terminate normally in
any finite number of steps.

This criteria matches non-halting input and it also matches the cases
where the input D has been intentionally defined to do the opposite of
whatever Boolean value that H returns.

When H returns 1 it means that its input halts and when H return 0
it means that either its input does not halt or D was intentionally
defined to do the opposite of whatever Boolean value that H returns.

To the best of my knowledge no one has ever made this much progress on
the halting problem's pathological input. To the best of my knowledge
everyone else was completely stumped by the halting problem's
pathological 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/20/23 11:09 AM, olcott wrote:
> On 6/20/2023 6:19 AM, Richard Damon wrote:
>> On 6/19/23 11:57 PM, olcott wrote:
>>> On 6/19/2023 7:45 PM, Richard Damon wrote:
>>>> On 6/19/23 10:30 AM, olcott wrote:
>>>>> On 6/19/2023 6:38 AM, Richard Damon wrote:
>>>>>> On 6/18/23 11:31 PM, olcott wrote:
>>>>>>> On 6/18/2023 9:38 PM, Richard Damon wrote:
>>>>>>>> On 6/18/23 9:43 PM, olcott wrote:
>>>>>>>>> On 6/18/2023 8:29 PM, Richard Damon wrote:
>>>>>>>>>> On 6/18/23 8:59 PM, olcott wrote:
>>>>>>>>>>> On 6/18/2023 7:01 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/18/23 7:41 PM, olcott wrote:
>>>>>>>>>>>>> On 6/18/2023 1:56 PM, Fritz Feldhase wrote:
>>>>>>>>>>>>>> On Sunday, June 18, 2023 at 8:09:51 PM UTC+2, olcott wrote
>>>>>>>>>>>>>> <nonsense>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A possible "practical solution" for an actual "halt
>>>>>>>>>>>>>> decider" might be something I will call a
>>>>>>>>>>>>>> semi-halt-decider here.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The latter allows for 3 answers (return values) when called:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H(P, d) -> 1 "P(d) halts"
>>>>>>>>>>>>>> H(P, d) -> -1 "P(d) doesn't halt."
>>>>>>>>>>>>>> H(P, d) -> 0 "Don't know/can't tell if P(d) halts or not"
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Such a semi-halt-decider might be able to determine _the
>>>>>>>>>>>>>> correct_ answer (1, -1) for a big class of casses. On the
>>>>>>>>>>>>>> other hand, it would always have the possibility to "give
>>>>>>>>>>>>>> up" (for certain cases) and anwer with 0: "Don't
>>>>>>>>>>>>>> know/can't tell" (and this way be able to avoid INCORRECT
>>>>>>>>>>>>>> ANSWERS concerning the actual behavior of P(d)).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The key difference with my work that is a true innovation
>>>>>>>>>>>>> in this field
>>>>>>>>>>>>> is that H doesn't simply give up. H specifically recognizes
>>>>>>>>>>>>> self-
>>>>>>>>>>>>> contradictory inputs and rejects them.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Termination Analyzer H prevents Denial of Service attacks*
>>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except the input isn't self-contradictory, since the input
>>>>>>>>>>>> can't exist until H is defined, and once H is defined, the
>>>>>>>>>>>> input has definite behavior, so there is no
>>>>>>>>>>>> self-contradiction possilble, only error.
>>>>>>>>>>> If I ask you what correct (yes or no) answer of could Jack
>>>>>>>>>>> reply with?
>>>>>>>>>>> Exactly why can’t you answer this?
>>>>>>>>>>
>>>>>>>>>> He has no answer that is correct, but that doesn't matter and
>>>>>>>>>> is just you faliing into the fallacy of the Red Herring.
>>>>>>>>>>
>>>>>>>>> // The following is written in C
>>>>>>>>> //
>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its
>>>>>>>>> input
>>>>>>>>> 03
>>>>>>>>> 04 int D(ptr x)
>>>>>>>>> 05 {
>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>> 09   return Halt_Status;
>>>>>>>>> 10 }
>>>>>>>>> 11
>>>>>>>>> 12 void main()
>>>>>>>>> 13 {
>>>>>>>>> 14   H(D,D);
>>>>>>>>> 15 }
>>>>>>>>>
>>>>>>>>> Since the above H is an unspecified wildcard you are free to
>>>>>>>>> encode it
>>>>>>>>> in any one of an infinite number of different ways and return any
>>>>>>>>> Boolean value that you want.
>>>>>>>>
>>>>>>>> Nope, D isn't a PROGRAM until H is DEFINED.
>>>>>>> That is why I triple dog dare you to define it or acknowledge
>>>>>>> that no
>>>>>>> such program can possibly be defined because the input D to any
>>>>>>> corresponding H is isomorphic to Jack's question posed to Jack.
>>>>>>
>>>>>> SO, you AGREE that a "Correct Halt Decider", as defined by the
>>>>>> Halting Problem, can't exist.
>>>>>>
>>>>>
>>>>> I don't agree that your understanding of the halting problem is
>>>>> correct.
>>>>> H is required to report on the actual behavior that it actually sees.
>>>>
>>>> Where does THAT come from. It may only be ABLE to do so, but the
>>>> REQUIREMENT is the behavior of the actual machine.
>>>>
>>>> You seem to have trouble with the English Languge.
>>>>
>>>> Please show me any reputable reference that says you get to
>>>> disregard the ACTUAL REQUIREMENTS because you can't see what you
>>>> need to do so
>>>>
>>>>>
>>>>> You and others are requiring H to report on behavior that it does not
>>>>> see. You already also admitted that when H reports on this behavior
>>>>> that
>>>>> it does not see that this changes this behavior that it does not see
>>>>> making its report incorrect.
>>>>
>>>> Yes, because that is what the requirements say. The requirements are
>>>> what the requirements say, because that is the requirements needed
>>>> to solve the mathematical problems that a Halt Decider is hoped to
>>>> be able to help with.
>>>>
>>>
>>> When the requirements are self-contradictory then they are incorrect.
>>
>> Whats self-contradictory of the ACTUAL QUESTION that is asked?
>>
>
> D was intentionally defined to do the opposite
> of whatever Boolean value that H returns.
>
> D was intentionally defined to do the opposite
> of whatever Boolean value that H returns.
>
> D was intentionally defined to do the opposite
> of whatever Boolean value that H returns.
>
> D was intentionally defined to do the opposite
> of whatever Boolean value that H returns.
>
> D was intentionally defined to do the opposite
> of whatever Boolean value that H returns.

So?

How does that make the question self-contradictory?

For any D defined (which first requires H to be fully defined) the
behavior of D(D) is precisely defined, so no self-contradiction to the
quesiton of "Does the machine described by this input Halt?"

Where is the ACTUAL contradiction to that answer. Remember, at the point
the question can be ask, H needs to be a DEFINED program, not just some
nebulous concept of how to do it.
>
>
> When we use the criteria:
> Can D correctly simulated by H ever terminate normally?

On 6/20/23 11:06 AM, olcott wrote:
> On 6/19/2023 3:08 PM, Ben Bacarisse wrote:
>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>
>>> On Monday, June 19, 2023 at 5:58:39 PM UTC+2, olcott wrote:
>>>
>>>> the full semantics of the question <bla>
>>>
>>> Look, dumbo, we are asking the simple question: "Does D(D) halt?"
>>>
>>> Now, D(D) either halts or doesn't halt.
>>>
>>> Hence the CORRECT yes/no-answer to the question "Does D(D) halt?" is
>>> "yes" iff D(D) halts and "no" if D(D) doesn't halt.
>>
>> Just a reminder that you are arguing with someone who has declared that
>> the wrong answer is the right one:
>>
>> Me: "do you still assert that [...] false is the "correct" answer even
>>      though P(P) halts?"
>>
>> PO: Yes that is the correct answer even though P(P) halts.
>>
>> (Back then, D was called P.)
>>
>> This was not a slip of the tongue.  He has been quite clear that he is
>> talking about something other than what the world calls halting.  It's
>> about what /would/ happen if the program were slight different, not
>> about what actually happens:
>>
>> PO: "A non-halting computation is every computation that never halts
>>      unless its simulation is aborted.  This maps to every element of the
>>      conventional halting problem set of non-halting computations and a
>>      few more."
>>
>> He has been (eventually) perfectly clear -- PO's "Other Halting" is not
>> halting, which is why false can be the correct answer for some halting
>> computations.  The only mystery is why anyone still wants to talk about
>> POOH.
>>
>
> Stop doing this Ben !!!
>
> When we use the criteria:
> Can D correctly simulated by H ever terminate normally?

So you are ADMITTING to working on a different problem, and lying about
what you are doing.

Ben is just pointing out the ERRORS in your logic

The fact you can't see that just shows your lack of understanding.

Just because you don't understand something doesn't make it
"inconsistent" or "invalid", the fact that only YOU don't understand it
shows that the problem is with you.

>
> After N steps of correct simulation the execution trace of D proves that
> D cannot possibly reach its final instruction and terminate normally in
> any finite number of steps.
>
> This criteria matches non-halting input and it also matches the cases
> where the input D has been intentionally defined to do the opposite of
> whatever Boolean value that H returns.
>
> When H returns 1 it means that its input halts and when H return 0
> it means that either its input does not halt or D was intentionally
> defined to do the opposite of whatever Boolean value that H returns.
>
> To the best of my knowledge no one has ever made this much progress on
> the halting problem's pathological input. To the best of my knowledge
> everyone else was completely stumped by the halting problem's
> pathological input.
>
>

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

>> On 6/19/2023 3:08 PM, Ben Bacarisse wrote:

>>> Me: "do you still assert that [...] false is the "correct" answer even
>>>      though P(P) halts?"
>>>
>>> PO: Yes that is the correct answer even though P(P) halts.
<cut>
>>> This was not a slip of the tongue.  He has been quite clear that he is
>>> talking about something other than what the world calls halting.  It's
>>> about what /would/ happen if the program were slight different, not
>>> about what actually happens:
>>>
>>> PO: "A non-halting computation is every computation that never halts
>>>      unless its simulation is aborted.  This maps to every element of the
>>>      conventional halting problem set of non-halting computations and a
>>>      few more."

> Ben is just pointing out the ERRORS in your logic

I don't think I pointed to any errors of logic. I just quoted PO so
that readers can see what he's talking about.

Why do you keep making posts with personally derogatory subject lines?
You are just amplifying his nasty voice.

--
Ben.