*Everyone agrees that this is impossible*
No computer program H can correctly predict what another computer
program D will do when D has been programmed to do the opposite of
whatever H says.

H(D) is functional notation that specifies the return value from H(D)
Correct(H(D)==false) means that H(D) is correct that D does not halt
Correct(H(D)==true) means that H(D) is correct that D does halt

For all H ∈ TM there exists input D such that
(Correct(H(D)==false) ∨ (Correct(H(D)==true))==false

*No one pays attention to what this impossibility means*
The halting problem is defined as an unsatisfiable specification thus
isomorphic to a question that has been defined to have no correct
answer.

What time is it (yes or no)?
has no correct answer because there is something wrong with the
question. In this case we know to blame the question and not the one
answering it.

When we understand that there are some inputs to every TM H that
contradict both Boolean return values that H could return then the
question: Does your input halt? is essentially a self-contradictory
(thus incorrect) question in these cases.

The inability to correctly answer an incorrect question places no actual
limit on anyone or anything.

This insight opens up an alternative treatment of these pathological
inputs the same way that ZFC handled Russell's Paradox.

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

On 10/29/23 10:30 AM, olcott wrote:
> *Everyone agrees that this is impossible*
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.
>

Good that you admit that.

> H(D) is functional notation that specifies the return value from H(D)
> Correct(H(D)==false) means that H(D) is correct that D does not halt
> Correct(H(D)==true) means that H(D) is correct that D does halt

Except that it should be H(D,D), since you need to give H the input that
D needs to be given.

So, your "Correct" function is false since H(D,D) will, as you just
agreed, never return the right answer for the D designed for it.

Note also, the FUNCTION Correct must return the value false if the H as
its input doesn't return a value in a finite number of steps, as that
makes H not actually a decider, so it is not a "correct decider".

>
> For all H ∈ TM there exists input D such that
> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false

Nope, try to give the case. You are just LYING here and showing your
ignorance.

Remember, each H above is a SPECIFIC Turing machine (and for each H
there will be a SPECIFC D, based on that SPECIFIC H, for which that
SPECIFIC H will get the answer wrong.

Remember, for EVERY actual SPECIFIC Turing Machine D (with input x) D(x)
will either Halt or Not.

For every actual SPECIFIC Turing Machine H, it will either give the
correct answer, so Correct will answer True, of H will either not answer
or give an incorrect answer, so Correct will answer False.

There is no case for a SPECIFIC H, and a SPECIFIC D that Correct(H(D))
doesn't have a True or False answer. Try to show the case.

Remember H is a SPECIFIC TM, (since H ∈ TM) not a "set" of Turing
Machines. Your "Correct" predicate doesn't take a "set" of Turing
Machines, but an individual Turing Machine, and the "Pathological" D
isn't built on a "Set" of Turing Machine, but an individual one.

The actual question is about a specific input, and that ALWAYS has a
correct answer, its just that some machihes won't get it right. And we
can show that for EVERY decider we can make, there WILL be some specific
input (depending on the specific decider we are looking at) that the
decider WILL get wrong.

Thus, non-computable valid problems exist, as shown by theory.

>
> *No one pays attention to what this impossibility means*
> The halting problem is defined as an unsatisfiable specification thus
> isomorphic to a question that has been defined to have no correct
> answer.

Nope, again your ignorance of the probem.

>
> What time is it (yes or no)?
> has no correct answer because there is something wrong with the
> question. In this case we know to blame the question and not the one
> answering it.

Right, THAT question has no correct answer.

Does D halt, HAS a correct answer, H just doesn't give it.

DIFFERENCE.

Shows you don't understand the problem.

>
> When we understand that there are some inputs to every TM H that
> contradict both Boolean return values that H could return then the
> question: Does your input halt? is essentially a self-contradictory
> (thus incorrect) question in these cases.

But there IS a "Correct Answer", so the QUESTION isn't actualy
self-contradictory.

You are showing your stupidity,

>
> The inability to correctly answer an incorrect question places no actual
> limit on anyone or anything.

Sure does, but you are too stupd to understand.

>
> This insight opens up an alternative treatment of these pathological
> inputs the same way that ZFC handled Russell's Paradox.
>

Nope. ZFC handled Russell's Paradox by deciding that we can't actually
logically talk about a truely "Unversal" set of all possible sets.

At best, your equivalence is just the admission that there IS a
limitation to computabilty, that there exist a class of properties of
Turing Machine that does exist and is valid (as the property is defined
for all Turing Machines) but can not be computed by another Turing
machine, given a proper description of the machine to be decided on.

That is EXACTLY the statement you have been trying to DISPROVE for all
these years, but seem to now be accepting, but still saying it doesn't
affect anything.

You are ADMITTING some things are not computable, and then saying this
fact doesn't limit what a computation can do.

That is like saying I know I can't get this car over 80 MPH, but there
is no limit to how fast this car can go.

Just a pitiful LIE.

On 10/29/2023 1:30 PM, olcott wrote:

> [Subject: Does the halting problem
> actually limit what computers can do?]

> The inability to correctly answer
> an incorrect question places
> no actual limit on anyone or anything.

The inability of a computer program
to correctly answer all halting-questions
*places* no actual limit on anyone or anything.

That's not how a theorem works.

Nothing which a theorem is about _changes_
in response to a proof.

_We_ change in response to a proof.
Our state of knowledge changes.

Before we know that
no computer program decides all halting questions,
no computer program decides all halting questions.

The difference, before and after,
is in _what we know_

----
We finites are able to learn of
the existence of a wall of infinitely-many bricks
without our having stacked infinitely-many bricks
one on another.

All I am saying is:
Nice!

On 10/29/2023 12:30 PM, olcott wrote:
> *Everyone agrees that this is impossible*
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.
>
> H(D) is functional notation that specifies the return value from H(D)
> Correct(H(D)==false) means that H(D) is correct that D does not halt
> Correct(H(D)==true) means that H(D) is correct that D does halt
>
> For all H ∈ TM there exists input D such that
> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>
> *No one pays attention to what this impossibility means*
> The halting problem is defined as an unsatisfiable specification thus
> isomorphic to a question that has been defined to have no correct
> answer.
>
> What time is it (yes or no)?
> has no correct answer because there is something wrong with the
> question. In this case we know to blame the question and not the one
> answering it.
>
> When we understand that there are some inputs to every TM H that
> contradict both Boolean return values that H could return then the
> question: Does your input halt? is essentially a self-contradictory
> (thus incorrect) question in these cases.
>
> The inability to correctly answer an incorrect question places no actual
> limit on anyone or anything.
>
> This insight opens up an alternative treatment of these pathological
> inputs the same way that ZFC handled Russell's Paradox.
>

No computer program H can correctly predict what another computer
program D will do when D has been programmed to do the opposite of
whatever H says.

Every H of the infinite set of all Turing machines gets the wrong
answer on their corresponding input D because this input D
essentially derives a self-contradictory thus incorrect question
for this H.

Like the question: What time is it (yes or no)?
the blame for the lack of a correct answer goes to the question
and not the one attempting to answer it.

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

On 10/29/23 10:30 AM, olcott wrote:
> *Everyone agrees that this is impossible*
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.
>
> H(D) is functional notation that specifies the return value from H(D)
> Correct(H(D)==false) means that H(D) is correct that D does not halt
> Correct(H(D)==true) means that H(D) is correct that D does halt

Noticed that I misread what "Correct" was defined as.

Note, that Correct(H(D) == value), where value is True/False can only be
true for the one value that H(D) does return, and the other, it can
NEVER be true.

Correct, as you have defined it, can't be used to determine if a
question actually has a correct value, only if H is correct in giving
its answer.

>
> For all H ∈ TM there exists input D such that
> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
First, that ISN'T necessarily a true statement, unless you are stating
that D is a dependent variable such that:

for all H ∈ TM, there exist a D ∈ representation(TM) such that
(Correct(H(D)==false) ∨ (Correct(H(D)==true))==false

So, all you are saying here is that for all H there exists a D that H(D)
happens to get the wrong answer. So what.

To point out the limitiation of your "Correct" predicate imagine that if
H instead of being a Halt Detector, was a Prime detector, but was
incorrectly programmed and it though 2 was not prime, then

H(2) == False

Correct(H(2) == true) is false since H(2) doesn't return 2, so it wasn't
correct in saying 2, and

Correct(H(2) == false) is false, since 2 is prime, so H is not correct
in saying it is not prime.

Thus: (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false

Doesn't say that the question is invalid, just that H got the answer wrong.

The fact that you can say the same for ALL possible Turing Macines,
still doesn't make the question "Wrong", just uncomputable.

You don't seem to understand that H(D) is a FIXED VALUE based on the
program of H, and that can ligitimately be WRONG

>
> *No one pays attention to what this impossibility means*
> The halting problem is defined as an unsatisfiable specification thus
> isomorphic to a question that has been defined to have no correct
> answer.
>
> What time is it (yes or no)?
> has no correct answer because there is something wrong with the
> question. In this case we know to blame the question and not the one
> answering it.
>
> When we understand that there are some inputs to every TM H that
> contradict both Boolean return values that H could return then the
> question: Does your input halt? is essentially a self-contradictory
> (thus incorrect) question in these cases.
>
> The inability to correctly answer an incorrect question places no actual
> limit on anyone or anything.
>
> This insight opens up an alternative treatment of these pathological
> inputs the same way that ZFC handled Russell's Paradox.
>

On 10/29/2023 12:30 PM, olcott wrote:
> *Everyone agrees that this is impossible*
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.
>
> H(D) is functional notation that specifies the return value from H(D)
> Correct(H(D)==false) means that H(D) is correct that D does not halt
> Correct(H(D)==true) means that H(D) is correct that D does halt
>
> For all H ∈ TM there exists input D such that
> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>
> *No one pays attention to what this impossibility means*
> The halting problem is defined as an unsatisfiable specification thus
> isomorphic to a question that has been defined to have no correct
> answer.
>
> What time is it (yes or no)?
> has no correct answer because there is something wrong with the
> question. In this case we know to blame the question and not the one
> answering it.
>
> When we understand that there are some inputs to every TM H that
> contradict both Boolean return values that H could return then the
> question: Does your input halt? is essentially a self-contradictory
> (thus incorrect) question in these cases.
>
> The inability to correctly answer an incorrect question places no actual
> limit on anyone or anything.
>
> This insight opens up an alternative treatment of these pathological
> inputs the same way that ZFC handled Russell's Paradox.
>

No computer program H can correctly predict what another computer
program D will do when D has been programmed to do the opposite of
whatever H says.

Every H of the infinite set of all Turing machines gets the wrong
answer on their corresponding input D because this input D
essentially derives a self-contradictory thus incorrect question
for this H.

Like the question: What time is it (yes or no)?
the blame for the lack of a correct answer goes to the question
and not the one attempting to answer it.

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

On 10/29/23 11:44 AM, olcott wrote:
> On 10/29/2023 12:30 PM, olcott wrote:
>> *Everyone agrees that this is impossible*
>> No computer program H can correctly predict what another computer
>> program D will do when D has been programmed to do the opposite of
>> whatever H says.
>>
>> H(D) is functional notation that specifies the return value from H(D)
>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>
>> For all H ∈ TM there exists input D such that
>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>
>> *No one pays attention to what this impossibility means*
>> The halting problem is defined as an unsatisfiable specification thus
>> isomorphic to a question that has been defined to have no correct
>> answer.
>>
>> What time is it (yes or no)?
>> has no correct answer because there is something wrong with the
>> question. In this case we know to blame the question and not the one
>> answering it.
>>
>> When we understand that there are some inputs to every TM H that
>> contradict both Boolean return values that H could return then the
>> question: Does your input halt? is essentially a self-contradictory
>> (thus incorrect) question in these cases.
>>
>> The inability to correctly answer an incorrect question places no actual
>> limit on anyone or anything.
>>
>> This insight opens up an alternative treatment of these pathological
>> inputs the same way that ZFC handled Russell's Paradox.
>>
>
>
>
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.

So?

Who says the need to be able to do it?

That is EXACTLY what the Theorem is proving, and which you admit, but
you want to refuse the logical consequence of it, because you don't

>
> Every H of the infinite set of all Turing machines gets the wrong
> answer on their corresponding input D because this input D
> essentially derives a self-contradictory thus incorrect question
> for this H.

Nope, you are confused by mixing sets with objects in the set.

Nice Category error there.

Every question in that set had a correct answer, that might have been
given by some members of the deciders in that set. That shows that the
actual QUESTION is VALID and not "self-contradictory"

The fact that every instance of the question has a correct answer, makes
it VALID.

The fact that every decider has such a question that it can't answer,
makes it uncomputable.

The fact that your Strawman version (What can H return to be correct)
doesn't have an answer is just part of the proof that the actual theorem
is proven, and just shows your ignorance of the subject.

>
> Like the question: What time is it (yes or no)?
> the blame for the lack of a correct answer goes to the question
> and not the one attempting to answer it.
>

Nope, Strawman. you like Strawman, I guess because they are just as
smart as you.

What time is it (yes or no)? doesn't have an answer.

Does a particual D(D) Halt, DOES have an answer, and it will always be
the opposite of what the H(D,D) returns for the SPECIFIC H that D was
built to refute.

Having an answer that ONE machine can't answer correctly is not like a
question that doesn't actually have a answer (due to a category error in
this case) is not the same.

Your thinking they are the same just proves your stupidity.

On 10/29/23 11:36 AM, olcott wrote:
> On 10/29/2023 12:30 PM, olcott wrote:
>> *Everyone agrees that this is impossible*
>> No computer program H can correctly predict what another computer
>> program D will do when D has been programmed to do the opposite of
>> whatever H says.
>>
>> H(D) is functional notation that specifies the return value from H(D)
>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>
>> For all H ∈ TM there exists input D such that
>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>
>> *No one pays attention to what this impossibility means*
>> The halting problem is defined as an unsatisfiable specification thus
>> isomorphic to a question that has been defined to have no correct
>> answer.
>>
>> What time is it (yes or no)?
>> has no correct answer because there is something wrong with the
>> question. In this case we know to blame the question and not the one
>> answering it.
>>
>> When we understand that there are some inputs to every TM H that
>> contradict both Boolean return values that H could return then the
>> question: Does your input halt? is essentially a self-contradictory
>> (thus incorrect) question in these cases.
>>
>> The inability to correctly answer an incorrect question places no actual
>> limit on anyone or anything.
>>
>> This insight opens up an alternative treatment of these pathological
>> inputs the same way that ZFC handled Russell's Paradox.
>>
>
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.
>
So?

Who says the need to be able to do it?

That is EXACTLY what the Theorem is proving, and which you admit, but
you want to refuse the logical consequence of it, because you don't
actually understand how logic or Truth works.

> Every H of the infinite set of all Turing machines gets the wrong
> answer on their corresponding input D because this input D
> essentially derives a self-contradictory thus incorrect question
> for this H.

Nope, you are confused by mixing sets with objects in the set.

Nice Category error there.

Every question in that set had a correct answer, that might have been
given by some members of the deciders in that set. That shows that the
actual QUESTION is VALID and not "self-contradictory"

The fact that every instance of the question has a correct answer, makes
it VALID.

The fact that every decider has such a question that it can't answer,
makes it uncomputable.

The fact that your Strawman version (What can H return to be correct)
doesn't have an answer is just part of the proof that the actual theorem
is proven, and just shows your ignorance of the subject.

>
> Like the question: What time is it (yes or no)?
> the blame for the lack of a correct answer goes to the question
> and not the one attempting to answer it.
>

Nope, Strawman. you like Strawman, I guess because they are just as
smart as you.

What time is it (yes or no)? doesn't have an answer.

Does a particual D(D) Halt, DOES have an answer, and it will always be
the opposite of what the H(D,D) returns for the SPECIFIC H that D was
built to refute.

Having an answer that ONE machine can't answer correctly is not like a
question that doesn't actually have a answer (due to a category error in
this case) is not the same.

Your thinking they are the same just proves your stupidity.

On 10/29/2023 1:44 PM, olcott wrote:
> On 10/29/2023 12:30 PM, olcott wrote:
>> *Everyone agrees that this is impossible*
>> No computer program H can correctly predict what another computer
>> program D will do when D has been programmed to do the opposite of
>> whatever H says.
>>
>> H(D) is functional notation that specifies the return value from H(D)
>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>
>> For all H ∈ TM there exists input D such that
>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>
>> *No one pays attention to what this impossibility means*
>> The halting problem is defined as an unsatisfiable specification thus
>> isomorphic to a question that has been defined to have no correct
>> answer.
>>
>> What time is it (yes or no)?
>> has no correct answer because there is something wrong with the
>> question. In this case we know to blame the question and not the one
>> answering it.
>>
>> When we understand that there are some inputs to every TM H that
>> contradict both Boolean return values that H could return then the
>> question: Does your input halt? is essentially a self-contradictory
>> (thus incorrect) question in these cases.
>>
>> The inability to correctly answer an incorrect question places no actual
>> limit on anyone or anything.
>>
>> This insight opens up an alternative treatment of these pathological
>> inputs the same way that ZFC handled Russell's Paradox.
>>
>
>
>
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.
>
> Every H of the infinite set of all Turing machines gets the wrong
> answer on their corresponding input D because this input D
> essentially derives a self-contradictory thus incorrect question
> for this H.
>

Changing the subject to a different H for this same input D is
the strawman deception.

Ignoring the context of who is asked the question deceptively
changes the meaning of the question.

> Like the question: What time is it (yes or no)?
> the blame for the lack of a correct answer goes to the question
> and not the one attempting to answer it.
>

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

On 10/29/23 12:25 PM, olcott wrote:
> On 10/29/2023 1:44 PM, olcott wrote:
>> On 10/29/2023 12:30 PM, olcott wrote:
>>> *Everyone agrees that this is impossible*
>>> No computer program H can correctly predict what another computer
>>> program D will do when D has been programmed to do the opposite of
>>> whatever H says.
>>>
>>> H(D) is functional notation that specifies the return value from H(D)
>>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>>
>>> For all H ∈ TM there exists input D such that
>>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>>
>>> *No one pays attention to what this impossibility means*
>>> The halting problem is defined as an unsatisfiable specification thus
>>> isomorphic to a question that has been defined to have no correct
>>> answer.
>>>
>>> What time is it (yes or no)?
>>> has no correct answer because there is something wrong with the
>>> question. In this case we know to blame the question and not the one
>>> answering it.
>>>
>>> When we understand that there are some inputs to every TM H that
>>> contradict both Boolean return values that H could return then the
>>> question: Does your input halt? is essentially a self-contradictory
>>> (thus incorrect) question in these cases.
>>>
>>> The inability to correctly answer an incorrect question places no actual
>>> limit on anyone or anything.
>>>
>>> This insight opens up an alternative treatment of these pathological
>>> inputs the same way that ZFC handled Russell's Paradox.
>>>
>>
>>
>>
>> No computer program H can correctly predict what another computer
>> program D will do when D has been programmed to do the opposite of
>> whatever H says.
>>
>> Every H of the infinite set of all Turing machines gets the wrong
>> answer on their corresponding input D because this input D
>> essentially derives a self-contradictory thus incorrect question
>> for this H.
>>
>
> Changing the subject to a different H for this same input D is
> the strawman deception.

YOU'RE the one that said "for all H", so the strawman is YOURS

>
> Ignoring the context of who is asked the question deceptively
> changes the meaning of the question.

Except that when the question's answer isn't affected by the context it
is asked,

"Does a SPECIFIED D(D) Halt?" is INDEPENDENT of whou you ask.

So, you are just showing you deceitfulness because will the question is
each time, about a SPECIFIC input, you try to change it to the input
associated with the decider deciding it, which is not a valid input.

You are just showing your stupidity by the form of your arguments.

>
>> Like the question: What time is it (yes or no)?
>> the blame for the lack of a correct answer goes to the question
>> and not the one attempting to answer it.
>>
>

On 10/29/2023 12:30 PM, olcott wrote:
> *Everyone agrees that this is impossible*
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.
>
> H(D) is functional notation that specifies the return value from H(D)
> Correct(H(D)==false) means that H(D) is correct that D does not halt
> Correct(H(D)==true) means that H(D) is correct that D does halt
>
> For all H ∈ TM there exists input D such that
> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>
> *No one pays attention to what this impossibility means*
> The halting problem is defined as an unsatisfiable specification thus
> isomorphic to a question that has been defined to have no correct
> answer.
>
> What time is it (yes or no)?
> has no correct answer because there is something wrong with the
> question. In this case we know to blame the question and not the one
> answering it.
>
> When we understand that there are some inputs to every TM H that
> contradict both Boolean return values that H could return then the
> question: Does your input halt? is essentially a self-contradictory
> (thus incorrect) question in these cases.
>
> The inability to correctly answer an incorrect question places no actual
> limit on anyone or anything.
>
> This insight opens up an alternative treatment of these pathological
> inputs the same way that ZFC handled Russell's Paradox.
>

Every H of the infinite set of all Turing machines gets the wrong
answer

on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D

because this input D essentially derives a self-contradictory thus
incorrect question for this H.

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

On 10/29/2023 12:30 PM, olcott wrote:
> *Everyone agrees that this is impossible*
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.
>
> H(D) is functional notation that specifies the return value from H(D)
> Correct(H(D)==false) means that H(D) is correct that D does not halt
> Correct(H(D)==true) means that H(D) is correct that D does halt
>
> For all H ∈ TM there exists input D such that
> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>
> *No one pays attention to what this impossibility means*
> The halting problem is defined as an unsatisfiable specification thus
> isomorphic to a question that has been defined to have no correct
> answer.
>
> What time is it (yes or no)?
> has no correct answer because there is something wrong with the
> question. In this case we know to blame the question and not the one
> answering it.
>
> When we understand that there are some inputs to every TM H that
> contradict both Boolean return values that H could return then the
> question: Does your input halt? is essentially a self-contradictory
> (thus incorrect) question in these cases.
>
> The inability to correctly answer an incorrect question places no actual
> limit on anyone or anything.
>
> This insight opens up an alternative treatment of these pathological
> inputs the same way that ZFC handled Russell's Paradox.
>

Every H of the infinite set of all Turing machines gets the wrong
answer

on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D
on their corresponding input D

because this input D
because this input D
because this input D
because this input D
because this input D

essentially derives a self-contradictory thus

incorrect question for this H.
incorrect question for this H.
incorrect question for this H.
incorrect question for this H.
incorrect question for this H.

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

On 10/29/23 1:10 PM, olcott wrote:
> On 10/29/2023 12:30 PM, olcott wrote:
>> *Everyone agrees that this is impossible*
>> No computer program H can correctly predict what another computer
>> program D will do when D has been programmed to do the opposite of
>> whatever H says.
>>
>> H(D) is functional notation that specifies the return value from H(D)
>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>
>> For all H ∈ TM there exists input D such that
>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>
>> *No one pays attention to what this impossibility means*
>> The halting problem is defined as an unsatisfiable specification thus
>> isomorphic to a question that has been defined to have no correct
>> answer.
>>
>> What time is it (yes or no)?
>> has no correct answer because there is something wrong with the
>> question. In this case we know to blame the question and not the one
>> answering it.
>>
>> When we understand that there are some inputs to every TM H that
>> contradict both Boolean return values that H could return then the
>> question: Does your input halt? is essentially a self-contradictory
>> (thus incorrect) question in these cases.
>>
>> The inability to correctly answer an incorrect question places no actual
>> limit on anyone or anything.
>>
>> This insight opens up an alternative treatment of these pathological
>> inputs the same way that ZFC handled Russell's Paradox.
>>
>
> Every H of the infinite set of all Turing machines gets the wrong
> answer
>
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
>
> because this input D essentially derives a self-contradictory thus
> incorrect question for this H.
>
>

Almost, but each is a DIFFERENT Question, and all the questions have
answer, and thus are VALID.

D isn't "Self-Contradictory", it is contadictory to a DIFFERENT machine
then itself.

I guess you are just showing you dont' know the meaning of "self"
because you are too stupid.

(and acting like a two year old in repeating your erroneous claim over
and over as a BIG LIE thinking that makes it more correct.

You still refuse to actually try to point out the actual errors in my
statement but continue to repeat your proven wrong statements, showing
that you are just a pitiful logical idiot.

"Does (a specific) D(D) as specified by the input Halt?" is a valid
question as it has a correct answer.

The fact we can come up with a D (different in each case) for ANY H, as
you have admitted, means the question is not computable.

Maybe you should try to prove your point with more that just an appeal
to a (proven incorrrect) authority (namely you).

Try starting out with some actual accepted definition of the terms and
use some sound logic (not sure you know any) to try to make you point.

Remember, the question you are trying to prove invalid is:

"Does the specific computation described by the input Halt when run?"

and not "What does H need to return to get the right answer?" (which is
an invalid question, as for ANY specific H, it CAN only return the
answer that its algorithm will compute, and a given H has a specified
specific algorithm).

and also not, "Does an H exist that can return the right value for the
D(D) derived fron it?" as that is asking not about a specific input, but
about the existance of a machine to compute something. Non-existance of
machines to do something is NOT a "error", but a sign the problem is
uncomputable, which is exactly the type of questin that Computabilyt
Theory investigates. What sort of questions ARE computable, and which
are not. Not being computable is an acceptable state for a problem.

On 10/29/23 1:15 PM, olcott wrote:
> On 10/29/2023 12:30 PM, olcott wrote:
>> *Everyone agrees that this is impossible*
>> No computer program H can correctly predict what another computer
>> program D will do when D has been programmed to do the opposite of
>> whatever H says.
>>
>> H(D) is functional notation that specifies the return value from H(D)
>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>
>> For all H ∈ TM there exists input D such that
>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>
>> *No one pays attention to what this impossibility means*
>> The halting problem is defined as an unsatisfiable specification thus
>> isomorphic to a question that has been defined to have no correct
>> answer.
>>
>> What time is it (yes or no)?
>> has no correct answer because there is something wrong with the
>> question. In this case we know to blame the question and not the one
>> answering it.
>>
>> When we understand that there are some inputs to every TM H that
>> contradict both Boolean return values that H could return then the
>> question: Does your input halt? is essentially a self-contradictory
>> (thus incorrect) question in these cases.
>>
>> The inability to correctly answer an incorrect question places no actual
>> limit on anyone or anything.
>>
>> This insight opens up an alternative treatment of these pathological
>> inputs the same way that ZFC handled Russell's Paradox.
>>
>
>
> Every H of the infinite set of all Turing machines gets the wrong
> answer
>
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
> on their corresponding input D
>
> because this input D
> because this input D
> because this input D
> because this input D
> because this input D
>
> essentially derives a self-contradictory thus
>
> incorrect question for this H.
> incorrect question for this H.
> incorrect question for this H.
> incorrect question for this H.
> incorrect question for this H.
>
>

Repeating your answer because you weren't two-yearold enough first time?

You also have a category error as you are conflating H as an "every"
machine of the set with THIS machie of the set.

For THIS machine of the set, and THIS D of the set, there IS an answer,
so the question is valid.

and, but each is a DIFFERENT Question, and all the questions have
answer, and thus are also VALID.

D isn't "Self-Contradictory", it is contradictory to a DIFFERENT machine
then itself.

I guess you are just showing you dont' know the meaning of "self"
because you are too stupid.

(and acting like a two year old in repeating your erroneous claim over
and over as a BIG LIE thinking that makes it more correct.

You still refuse to actually try to point out the actual errors in my
statement but continue to repeat your proven wrong statements, showing
that you are just a pitiful logical idiot.

"Does (a specific) D(D) as specified by the input Halt?" is a valid
question as it has a correct answer.

The fact we can come up with a D (different in each case) for ANY H, as
you have admitted, means the question is not computable.

Maybe you should try to prove your point with more that just an appeal
to a (proven incorrrect) authority (namely you).

Try starting out with some actual accepted definition of the terms and
use some sound logic (not sure you know any) to try to make you point.

Remember, the question you are trying to prove invalid is:

"Does the specific computation described by the input Halt when run?"

and not "What does H need to return to get the right answer?" (which is
an invalid question, as for ANY specific H, it CAN only return the
answer that its algorithm will compute, and a given H has a specified
specific algorithm).

and also not, "Does an H exist that can return the right value for the
D(D) derived fron it?" as that is asking not about a specific input, but
about the existance of a machine to compute something. Non-existance of
machines to do something is NOT a "error", but a sign the problem is
uncomputable, which is exactly the type of questin that Computabilyt
Theory investigates. What sort of questions ARE computable, and which
are not. Not being computable is an acceptable state for a problem.
[http://www.mozilla.com/thunderbird/]
[Options]

On 10/29/2023 12:30 PM, olcott wrote:
> *Everyone agrees that this is impossible*
> No computer program H can correctly predict what another computer
> program D will do when D has been programmed to do the opposite of
> whatever H says.
>
> H(D) is functional notation that specifies the return value from H(D)
> Correct(H(D)==false) means that H(D) is correct that D does not halt
> Correct(H(D)==true) means that H(D) is correct that D does halt
>
> For all H ∈ TM there exists input D such that
> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>
> *No one pays attention to what this impossibility means*
> The halting problem is defined as an unsatisfiable specification thus
> isomorphic to a question that has been defined to have no correct
> answer.
>
> What time is it (yes or no)?
> has no correct answer because there is something wrong with the
> question. In this case we know to blame the question and not the one
> answering it.
>
> When we understand that there are some inputs to every TM H that
> contradict both Boolean return values that H could return then the
> question: Does your input halt? is essentially a self-contradictory
> (thus incorrect) question in these cases.
>
> The inability to correctly answer an incorrect question places no actual
> limit on anyone or anything.
>
> This insight opens up an alternative treatment of these pathological
> inputs the same way that ZFC handled Russell's Paradox.
>

The halting problem proofs merely show that the problem
definition is unsatisfiable because every H of the infinite
set of all Turing Machines has an input that makes the
question: Does your input halt? into a self-contradictory
thus incorrect question for this H.

The only rebuttals to this in the last two years rely
on one form of the strawman deception of another.

*Stupid or dishonest people may say otherwise*
That every D has a halt decider has nothing to do with
the claim that every H has an undecidable 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 10/29/23 1:58 PM, olcott wrote:
> On 10/29/2023 12:30 PM, olcott wrote:
>> *Everyone agrees that this is impossible*
>> No computer program H can correctly predict what another computer
>> program D will do when D has been programmed to do the opposite of
>> whatever H says.
>>
>> H(D) is functional notation that specifies the return value from H(D)
>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>
>> For all H ∈ TM there exists input D such that
>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>
>> *No one pays attention to what this impossibility means*
>> The halting problem is defined as an unsatisfiable specification thus
>> isomorphic to a question that has been defined to have no correct
>> answer.
>>
>> What time is it (yes or no)?
>> has no correct answer because there is something wrong with the
>> question. In this case we know to blame the question and not the one
>> answering it.
>>
>> When we understand that there are some inputs to every TM H that
>> contradict both Boolean return values that H could return then the
>> question: Does your input halt? is essentially a self-contradictory
>> (thus incorrect) question in these cases.
>>
>> The inability to correctly answer an incorrect question places no actual
>> limit on anyone or anything.
>>
>> This insight opens up an alternative treatment of these pathological
>> inputs the same way that ZFC handled Russell's Paradox.
>>
>
> The halting problem proofs merely show that the problem
> definition is unsatisfiable because every H of the infinite
> set of all Turing Machines has an input that makes the
> question: Does your input halt? into a self-contradictory
> thus incorrect question for this H.

So, you are just showing that you don't know what "satisfiable" means in
logic, just showing off your ignorance (even though you have been told
before, I guess you are to stupid to learn).

You also seem to not understand what the "self" part of
"self-contradictory" means, again, because you are too stupid to
understand when taught.

You also are repeating your category error by confusing specific
questions for sets of questios.

>
> The only rebuttals to this in the last two years rely
> on one form of the strawman deception of another.
>

Nope, your failure to actually point to an error shows that you don't
understand how logic works.

If my replies are strawman, you can point to the claim that isn't
actually correct, and reference the accepted definition of the problem
to show where they differ.

The problem here is that you are just projecting, as a fundamental part
of the problem is you try to change the fundamental nature of the
problem by building your own strawman, and when I knock them down, you
claim my reassertion of the actual problem is a strawman, because you
can't recognise the actual problem.

> *Stupid or dishonest people may say otherwise*
> That every D has a halt decider has nothing to do with
> the claim that every H has an undecidable input.
>

So, more stupid errors.

the "input" is not "undecidable", as for every specific H, there is a
specific D(D), and that input has a definite behavior so the quesiton of
its Halt is valid.

Also, due to the limited nature of your H's design, that inputs behavior
IS decidable by another decider, and "decidable" just requires that
there exist SOME decider (which doesn't need to be your H) that can
answer the question correctly, and that exists, you have even shown how
to build it (your H1).

Thus, it isn't that the "input" is undecidable, it is that the PROBLEM
isn't, as no one machine can compute the answer for every possible input.

AGAIN, you are showing your STUPIDITY and IGNORANCE.

On 10/29/2023 3:58 PM, olcott wrote:
> On 10/29/2023 12:30 PM, olcott wrote:
>> *Everyone agrees that this is impossible*
>> No computer program H can correctly predict what another computer
>> program D will do when D has been programmed to do the opposite of
>> whatever H says.
>>
>> H(D) is functional notation that specifies the return value from H(D)
>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>
>> For all H ∈ TM there exists input D such that
>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>
>> *No one pays attention to what this impossibility means*
>> The halting problem is defined as an unsatisfiable specification thus
>> isomorphic to a question that has been defined to have no correct
>> answer.
>>
>> What time is it (yes or no)?
>> has no correct answer because there is something wrong with the
>> question. In this case we know to blame the question and not the one
>> answering it.
>>
>> When we understand that there are some inputs to every TM H that
>> contradict both Boolean return values that H could return then the
>> question: Does your input halt? is essentially a self-contradictory
>> (thus incorrect) question in these cases.
>>
>> The inability to correctly answer an incorrect question places no actual
>> limit on anyone or anything.
>>
>> This insight opens up an alternative treatment of these pathological
>> inputs the same way that ZFC handled Russell's Paradox.
>>
>
> The halting problem proofs merely show that the problem
> definition is unsatisfiable because every H of the infinite
> set of all Turing Machines has an input that makes the
> question: Does your input halt? into a self-contradictory
> thus incorrect question for this H.

I now have two University professors that agree with this.
My words may need some technical improvement...

[problem specification] is unsatisfiable

The idea is to convey the essence of many technical
papers in a single sound bite:

*The halting problem proofs merely show that*
*self-contradictory questions have no correct answer*

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

On 10/29/23 3:38 PM, olcott wrote:
> On 10/29/2023 3:58 PM, olcott wrote:
>> On 10/29/2023 12:30 PM, olcott wrote:
>>> *Everyone agrees that this is impossible*
>>> No computer program H can correctly predict what another computer
>>> program D will do when D has been programmed to do the opposite of
>>> whatever H says.
>>>
>>> H(D) is functional notation that specifies the return value from H(D)
>>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>>
>>> For all H ∈ TM there exists input D such that
>>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>>
>>> *No one pays attention to what this impossibility means*
>>> The halting problem is defined as an unsatisfiable specification thus
>>> isomorphic to a question that has been defined to have no correct
>>> answer.
>>>
>>> What time is it (yes or no)?
>>> has no correct answer because there is something wrong with the
>>> question. In this case we know to blame the question and not the one
>>> answering it.
>>>
>>> When we understand that there are some inputs to every TM H that
>>> contradict both Boolean return values that H could return then the
>>> question: Does your input halt? is essentially a self-contradictory
>>> (thus incorrect) question in these cases.
>>>
>>> The inability to correctly answer an incorrect question places no actual
>>> limit on anyone or anything.
>>>
>>> This insight opens up an alternative treatment of these pathological
>>> inputs the same way that ZFC handled Russell's Paradox.
>>>
>>
>> The halting problem proofs merely show that the problem
>> definition is unsatisfiable because every H of the infinite
>> set of all Turing Machines has an input that makes the
>> question: Does your input halt? into a self-contradictory
>> thus incorrect question for this H.
>
> I now have two University professors that agree with this.
> My words may need some technical improvement...
>
> [problem specification] is unsatisfiable
>
> The idea is to convey the essence of many technical
> papers in a single sound bite:
>
> *The halting problem proofs merely show that*
> *self-contradictory questions have no correct answer*
>
>

Anonymous experts are not "evidence" and no "expert" can contradict the
actual definitions.

Especially when you don't even quote the actual words used, since you
have shown youself to misinterprete what they are saying or have used
misleading wording where they will interpret your words to mean what
they are supposed to mean, and not you corrupted meaning.

You are just continuing to prove that you do not understand how logic
works, and by not even trying to refute the rebuttal are accepting them
as correct responses, and thus admitting you are just a stupid liar.

As pointed out, the actual questions DO have answer, so you are just an
unsound liar by your arguements that they do not.

You are just making sure that you name will be MUD for as long as it is
remembered, until it falls in the trash heap of history.

This will also mean that any good ideas you might have had have been
poisoned and worthless.

You have just gas-lighted your self into being just a babbling idiot
that can only repeat the lies he convinced himself of, with no actual
logical backing.

Too bad.

On 10/29/2023 5:38 PM, olcott wrote:
> On 10/29/2023 3:58 PM, olcott wrote:
>> On 10/29/2023 12:30 PM, olcott wrote:
>>> *Everyone agrees that this is impossible*
>>> No computer program H can correctly predict what another computer
>>> program D will do when D has been programmed to do the opposite of
>>> whatever H says.
>>>
>>> H(D) is functional notation that specifies the return value from H(D)
>>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>>
>>> For all H ∈ TM there exists input D such that
>>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>>
>>> *No one pays attention to what this impossibility means*
>>> The halting problem is defined as an unsatisfiable specification thus
>>> isomorphic to a question that has been defined to have no correct
>>> answer.
>>>
>>> What time is it (yes or no)?
>>> has no correct answer because there is something wrong with the
>>> question. In this case we know to blame the question and not the one
>>> answering it.
>>>
>>> When we understand that there are some inputs to every TM H that
>>> contradict both Boolean return values that H could return then the
>>> question: Does your input halt? is essentially a self-contradictory
>>> (thus incorrect) question in these cases.
>>>
>>> The inability to correctly answer an incorrect question places no actual
>>> limit on anyone or anything.
>>>
>>> This insight opens up an alternative treatment of these pathological
>>> inputs the same way that ZFC handled Russell's Paradox.
>>>
>>
>> The halting problem proofs merely show that the problem
>> definition is unsatisfiable because every H of the infinite
>> set of all Turing Machines has an input that makes the
>> question: Does your input halt? into a self-contradictory
>> thus incorrect question for this H.
>
> I now have two University professors that agree with this.
> My words may need some technical improvement...
>
> [problem specification] is unsatisfiable
>
> The idea is to convey the essence of many technical
> papers in a single sound bite:
>
> *The halting problem proofs merely show that*
> *self-contradictory questions have no correct answer*

Anonymous experts are not "evidence"
and no "expert" can contradict the
actual definitions.

The whole thing is a matter of these definitions
semantically entailing additional nuances of meaning
that no one ever noticed before.

Computer scientists almost never pay any attention
at all to the philosophical underpinnings of the
foundations of concepts such as undecidability.

All of my related work in the last twenty years
has focused on these foundational underpinnings.

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

On 10/29/23 4:43 PM, olcott wrote:
> On 10/29/2023 5:38 PM, olcott wrote:
>> On 10/29/2023 3:58 PM, olcott wrote:
>>> On 10/29/2023 12:30 PM, olcott wrote:
>>>> *Everyone agrees that this is impossible*
>>>> No computer program H can correctly predict what another computer
>>>> program D will do when D has been programmed to do the opposite of
>>>> whatever H says.
>>>>
>>>> H(D) is functional notation that specifies the return value from H(D)
>>>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>>>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>>>
>>>> For all H ∈ TM there exists input D such that
>>>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>>>
>>>> *No one pays attention to what this impossibility means*
>>>> The halting problem is defined as an unsatisfiable specification thus
>>>> isomorphic to a question that has been defined to have no correct
>>>> answer.
>>>>
>>>> What time is it (yes or no)?
>>>> has no correct answer because there is something wrong with the
>>>> question. In this case we know to blame the question and not the one
>>>> answering it.
>>>>
>>>> When we understand that there are some inputs to every TM H that
>>>> contradict both Boolean return values that H could return then the
>>>> question: Does your input halt? is essentially a self-contradictory
>>>> (thus incorrect) question in these cases.
>>>>
>>>> The inability to correctly answer an incorrect question places no
>>>> actual
>>>> limit on anyone or anything.
>>>>
>>>> This insight opens up an alternative treatment of these pathological
>>>> inputs the same way that ZFC handled Russell's Paradox.
>>>>
>>>
>>> The halting problem proofs merely show that the problem
>>> definition is unsatisfiable because every H of the infinite
>>> set of all Turing Machines has an input that makes the
>>> question: Does your input halt? into a self-contradictory
>>> thus incorrect question for this H.
>>
>> I now have two University professors that agree with this.
>> My words may need some technical improvement...
>>
>> [problem specification] is unsatisfiable
>>
>> The idea is to convey the essence of many technical
>> papers in a single sound bite:
>>
>> *The halting problem proofs merely show that*
>> *self-contradictory questions have no correct answer*
>
>    Anonymous experts are not "evidence"
>    and no "expert" can contradict the
>    actual definitions.
>
> The whole thing is a matter of these definitions
> semantically entailing additional nuances of meaning
> that no one ever noticed before.

Since you are so bad at the actual definition of words, it seems more
like you are imagining things that aren't there.

If you HAVE found an actual "nuances" that hasn't been noticed before,
maybe if you try an actual step by step proof showing that "nuance".

I don't think you can, and this is just another case of an idiot
shooting at a target that just doesn't exist.

>
> Computer scientists almost never pay any attention
> at all to the philosophical underpinnings of the
> foundations of concepts such as undecidability.

Maybe it is the philosophers that don't understand that undeciability is
a PRECISELY defined quantity.

The thing that you don't seem to understand is that in Formal Systems,
the rules are very important, and the things you are talking about are
well established by those rules.

If you want to change the "Rules" of the system, then you are in a very
real sense needing to START OVER and buid back up from the ground up.

It seems that you are so ignorant, that you don't understand that many
of your "new" ideas are actually existing, but becuase of the discovered
limitations, just parts of fringe systems.

Yes, you can have systems where all true statements are provable, but
the resulting system ends up very limited in scope, and can't be used to
form anything like the mathematics that support things like Computation
Theory.

>
> All of my related work in the last twenty years
> has focused on these foundational underpinnings.
>

And is a pile of rubbish, because you don't actually seem to know what
the thigs actually mean.

Maybe if you were willing to actually LEARN about the systems you want
to talk about, but your stated fear of "Learning error by rote" as put
you in the state of Being in Error by Ignorance.

Your idea of building a system from "First Principles" requires you to
first actually LEARN those "First Principles". And for a "Formal Logic
System" that means at least enough to know all the basic rules and
definitons of the system. Things you have at time just admitted you
never knew, which sort of negates any "First Principle" developement you
might have done.

I will say that many of your errors where known about 100 years ago, so
it shows a glaring hole in your education.

On 10/29/2023 6:43 PM, olcott wrote:
> On 10/29/2023 5:38 PM, olcott wrote:
>> On 10/29/2023 3:58 PM, olcott wrote:
>>> On 10/29/2023 12:30 PM, olcott wrote:
>>>> *Everyone agrees that this is impossible*
>>>> No computer program H can correctly predict what another computer
>>>> program D will do when D has been programmed to do the opposite of
>>>> whatever H says.
>>>>
>>>> H(D) is functional notation that specifies the return value from H(D)
>>>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>>>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>>>
>>>> For all H ∈ TM there exists input D such that
>>>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>>>
>>>> *No one pays attention to what this impossibility means*
>>>> The halting problem is defined as an unsatisfiable specification thus
>>>> isomorphic to a question that has been defined to have no correct
>>>> answer.
>>>>
>>>> What time is it (yes or no)?
>>>> has no correct answer because there is something wrong with the
>>>> question. In this case we know to blame the question and not the one
>>>> answering it.
>>>>
>>>> When we understand that there are some inputs to every TM H that
>>>> contradict both Boolean return values that H could return then the
>>>> question: Does your input halt? is essentially a self-contradictory
>>>> (thus incorrect) question in these cases.
>>>>
>>>> The inability to correctly answer an incorrect question places no
>>>> actual
>>>> limit on anyone or anything.
>>>>
>>>> This insight opens up an alternative treatment of these pathological
>>>> inputs the same way that ZFC handled Russell's Paradox.
>>>>
>>>
>>> The halting problem proofs merely show that the problem
>>> definition is unsatisfiable because every H of the infinite
>>> set of all Turing Machines has an input that makes the
>>> question: Does your input halt? into a self-contradictory
>>> thus incorrect question for this H.
>>
>> I now have two University professors that agree with this.
>> My words may need some technical improvement...
>>
>> [problem specification] is unsatisfiable
>>
>> The idea is to convey the essence of many technical
>> papers in a single sound bite:
>>
>> *The halting problem proofs merely show that*
>> *self-contradictory questions have no correct answer*
>
>    Anonymous experts are not "evidence"
>    and no "expert" can contradict the
>    actual definitions.
>
> The whole thing is a matter of these definitions
> semantically entailing additional nuances of meaning
> that no one ever noticed before.
>
> Computer scientists almost never pay any attention
> at all to the philosophical underpinnings of the
> foundations of concepts such as undecidability.
>
> All of my related work in the last twenty years
> has focused on these foundational underpinnings.
>

In the same way that incompleteness is proven whenever
any WFF of a formal system cannot be proven or refuted
in this formal system EVEN WHEN THE WFF IS SEMANTICALLY
SELF-CONTRADICTORY

The notion of undecidability is determined even when the
decider is required to correctly answer a self-contradictory
(thus incorrect) question.

This is the epiphany of my work for the last 20 years and
two professors agree that this does apply to the halting
problem specification.

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

On 10/29/23 5:57 PM, olcott wrote:
> On 10/29/2023 6:43 PM, olcott wrote:
>> On 10/29/2023 5:38 PM, olcott wrote:
>>> On 10/29/2023 3:58 PM, olcott wrote:
>>>> On 10/29/2023 12:30 PM, olcott wrote:
>>>>> *Everyone agrees that this is impossible*
>>>>> No computer program H can correctly predict what another computer
>>>>> program D will do when D has been programmed to do the opposite of
>>>>> whatever H says.
>>>>>
>>>>> H(D) is functional notation that specifies the return value from H(D)
>>>>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>>>>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>>>>
>>>>> For all H ∈ TM there exists input D such that
>>>>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>>>>
>>>>> *No one pays attention to what this impossibility means*
>>>>> The halting problem is defined as an unsatisfiable specification thus
>>>>> isomorphic to a question that has been defined to have no correct
>>>>> answer.
>>>>>
>>>>> What time is it (yes or no)?
>>>>> has no correct answer because there is something wrong with the
>>>>> question. In this case we know to blame the question and not the one
>>>>> answering it.
>>>>>
>>>>> When we understand that there are some inputs to every TM H that
>>>>> contradict both Boolean return values that H could return then the
>>>>> question: Does your input halt? is essentially a self-contradictory
>>>>> (thus incorrect) question in these cases.
>>>>>
>>>>> The inability to correctly answer an incorrect question places no
>>>>> actual
>>>>> limit on anyone or anything.
>>>>>
>>>>> This insight opens up an alternative treatment of these pathological
>>>>> inputs the same way that ZFC handled Russell's Paradox.
>>>>>
>>>>
>>>> The halting problem proofs merely show that the problem
>>>> definition is unsatisfiable because every H of the infinite
>>>> set of all Turing Machines has an input that makes the
>>>> question: Does your input halt? into a self-contradictory
>>>> thus incorrect question for this H.
>>>
>>> I now have two University professors that agree with this.
>>> My words may need some technical improvement...
>>>
>>> [problem specification] is unsatisfiable
>>>
>>> The idea is to convey the essence of many technical
>>> papers in a single sound bite:
>>>
>>> *The halting problem proofs merely show that*
>>> *self-contradictory questions have no correct answer*
>>
>>     Anonymous experts are not "evidence"
>>     and no "expert" can contradict the
>>     actual definitions.
>>
>> The whole thing is a matter of these definitions
>> semantically entailing additional nuances of meaning
>> that no one ever noticed before.
>>
>> Computer scientists almost never pay any attention
>> at all to the philosophical underpinnings of the
>> foundations of concepts such as undecidability.
>>
>> All of my related work in the last twenty years
>> has focused on these foundational underpinnings.
>>
>
> In the same way that incompleteness is proven whenever
> any WFF of a formal system cannot be proven or refuted
> in this formal system EVEN WHEN THE WFF IS SEMANTICALLY
> SELF-CONTRADICTORY

Except it isn't, becuase you don't understand the logic.

>
> The notion of undecidability is determined even when the
> decider is required to correctly answer a self-contradictory
> (thus incorrect) question.

Which it isn't, and you don't understand the term.

>
> This is the epiphany of my work for the last 20 years and
> two professors agree that this does apply to the halting
> problem specification.
>

yes, your "epiphany" is just your delusion from stupidity.

You have PROVEN you don't understand a thing about what you are talking
about and thus prove yourself a liar.

As I mentioned, if you really think you have something, try to actually
show it with a real formal proof starting from the actual accepted
definitions.

Your problem seems to be that you just don't understand the fields well
enough to know what you can actually start with, or logic enough to
actually form a real logical proof.

Your just repeating your INCORRECT claims, just proves that you have
gas-light yourself into beliving your lies, and that you actually have
nothing to base your work on, except your own stupid lies.

On 10/29/2023 7:57 PM, olcott wrote:
> On 10/29/2023 6:43 PM, olcott wrote:
>> On 10/29/2023 5:38 PM, olcott wrote:
>>> On 10/29/2023 3:58 PM, olcott wrote:
>>>> On 10/29/2023 12:30 PM, olcott wrote:
>>>>> *Everyone agrees that this is impossible*
>>>>> No computer program H can correctly predict what another computer
>>>>> program D will do when D has been programmed to do the opposite of
>>>>> whatever H says.
>>>>>
>>>>> H(D) is functional notation that specifies the return value from H(D)
>>>>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>>>>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>>>>
>>>>> For all H ∈ TM there exists input D such that
>>>>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>>>>
>>>>> *No one pays attention to what this impossibility means*
>>>>> The halting problem is defined as an unsatisfiable specification thus
>>>>> isomorphic to a question that has been defined to have no correct
>>>>> answer.
>>>>>
>>>>> What time is it (yes or no)?
>>>>> has no correct answer because there is something wrong with the
>>>>> question. In this case we know to blame the question and not the one
>>>>> answering it.
>>>>>
>>>>> When we understand that there are some inputs to every TM H that
>>>>> contradict both Boolean return values that H could return then the
>>>>> question: Does your input halt? is essentially a self-contradictory
>>>>> (thus incorrect) question in these cases.
>>>>>
>>>>> The inability to correctly answer an incorrect question places no
>>>>> actual
>>>>> limit on anyone or anything.
>>>>>
>>>>> This insight opens up an alternative treatment of these pathological
>>>>> inputs the same way that ZFC handled Russell's Paradox.
>>>>>
>>>>
>>>> The halting problem proofs merely show that the problem
>>>> definition is unsatisfiable because every H of the infinite
>>>> set of all Turing Machines has an input that makes the
>>>> question: Does your input halt? into a self-contradictory
>>>> thus incorrect question for this H.
>>>
>>> I now have two University professors that agree with this.
>>> My words may need some technical improvement...
>>>
>>> [problem specification] is unsatisfiable
>>>
>>> The idea is to convey the essence of many technical
>>> papers in a single sound bite:
>>>
>>> *The halting problem proofs merely show that*
>>> *self-contradictory questions have no correct answer*
>>
>>     Anonymous experts are not "evidence"
>>     and no "expert" can contradict the
>>     actual definitions.
>>
>> The whole thing is a matter of these definitions
>> semantically entailing additional nuances of meaning
>> that no one ever noticed before.
>>
>> Computer scientists almost never pay any attention
>> at all to the philosophical underpinnings of the
>> foundations of concepts such as undecidability.
>>
>> All of my related work in the last twenty years
>> has focused on these foundational underpinnings.
>>
>
> In the same way that incompleteness is proven whenever
> any WFF of a formal system cannot be proven or refuted
> in this formal system EVEN WHEN THE WFF IS SEMANTICALLY
> SELF-CONTRADICTORY
>
> The notion of undecidability is determined even when the
> decider is required to correctly answer a self-contradictory
> (thus incorrect) question.
>
> This is the epiphany of my work for the last 20 years and
> two professors agree that this does apply to the halting
> problem specification.
>

I cannot form a proof on the basis of the conventional
definitions because the issue is that one of these
definitions semantically entails more meaning than
anyone ever noticed before.

That this applies generically to the notion of undecidability
seems to be an extension of these sames ideas that these
professors only applied to the halting problem specification.

The lead of these two professors and I exchanged fifty emails
where he confirmed my verbatim paraphrase of his ideas using
my own terms such as "incorrect questions".

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

On 10/29/23 6:19 PM, olcott wrote:
> On 10/29/2023 7:57 PM, olcott wrote:
>> On 10/29/2023 6:43 PM, olcott wrote:
>>> On 10/29/2023 5:38 PM, olcott wrote:
>>>> On 10/29/2023 3:58 PM, olcott wrote:
>>>>> On 10/29/2023 12:30 PM, olcott wrote:
>>>>>> *Everyone agrees that this is impossible*
>>>>>> No computer program H can correctly predict what another computer
>>>>>> program D will do when D has been programmed to do the opposite of
>>>>>> whatever H says.
>>>>>>
>>>>>> H(D) is functional notation that specifies the return value from H(D)
>>>>>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>>>>>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>>>>>
>>>>>> For all H ∈ TM there exists input D such that
>>>>>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>>>>>
>>>>>> *No one pays attention to what this impossibility means*
>>>>>> The halting problem is defined as an unsatisfiable specification thus
>>>>>> isomorphic to a question that has been defined to have no correct
>>>>>> answer.
>>>>>>
>>>>>> What time is it (yes or no)?
>>>>>> has no correct answer because there is something wrong with the
>>>>>> question. In this case we know to blame the question and not the one
>>>>>> answering it.
>>>>>>
>>>>>> When we understand that there are some inputs to every TM H that
>>>>>> contradict both Boolean return values that H could return then the
>>>>>> question: Does your input halt? is essentially a self-contradictory
>>>>>> (thus incorrect) question in these cases.
>>>>>>
>>>>>> The inability to correctly answer an incorrect question places no
>>>>>> actual
>>>>>> limit on anyone or anything.
>>>>>>
>>>>>> This insight opens up an alternative treatment of these pathological
>>>>>> inputs the same way that ZFC handled Russell's Paradox.
>>>>>>
>>>>>
>>>>> The halting problem proofs merely show that the problem
>>>>> definition is unsatisfiable because every H of the infinite
>>>>> set of all Turing Machines has an input that makes the
>>>>> question: Does your input halt? into a self-contradictory
>>>>> thus incorrect question for this H.
>>>>
>>>> I now have two University professors that agree with this.
>>>> My words may need some technical improvement...
>>>>
>>>> [problem specification] is unsatisfiable
>>>>
>>>> The idea is to convey the essence of many technical
>>>> papers in a single sound bite:
>>>>
>>>> *The halting problem proofs merely show that*
>>>> *self-contradictory questions have no correct answer*
>>>
>>>     Anonymous experts are not "evidence"
>>>     and no "expert" can contradict the
>>>     actual definitions.
>>>
>>> The whole thing is a matter of these definitions
>>> semantically entailing additional nuances of meaning
>>> that no one ever noticed before.
>>>
>>> Computer scientists almost never pay any attention
>>> at all to the philosophical underpinnings of the
>>> foundations of concepts such as undecidability.
>>>
>>> All of my related work in the last twenty years
>>> has focused on these foundational underpinnings.
>>>
>>
>> In the same way that incompleteness is proven whenever
>> any WFF of a formal system cannot be proven or refuted
>> in this formal system EVEN WHEN THE WFF IS SEMANTICALLY
>> SELF-CONTRADICTORY
>>
>> The notion of undecidability is determined even when the
>> decider is required to correctly answer a self-contradictory
>> (thus incorrect) question.
>>
>> This is the epiphany of my work for the last 20 years and
>> two professors agree that this does apply to the halting
>> problem specification.
>>
>
> I cannot form a proof on the basis of the conventional
> definitions because the issue is that one of these
> definitions semantically entails more meaning than
> anyone ever noticed before.

Then you are admtting that you can't do the work in the formal system,
so any claim you make about anything IN the system is just invalid.

IF you want to try to change the definitions, you need to just redrive
the system from the ground up with your new rules. (I doubt you can do
that).

Or, you could try to get some help by trying to clearly explain the
error in the fundamental rules you think are wrong.

Note, to do that you need to actually show the real problem that the
rule is causing.

Your idea that undecidable problem are actually invalid isn't going to
fly, as many of the undecidable problems are actually quite important.

The fact that you can't understand that, means you are going to have a
hard time convincing others or your ideas.

>
> That this applies generically to the notion of undecidability
> seems to be an extension of these sames ideas that these
> professors only applied to the halting problem specification.

You have very bad professors if they only apply "undeciability" to just
the Halting Problem, as MANY problems are "undecidable".

>
> The lead of these two professors and I exchanged fifty emails
> where he confirmed my verbatim paraphrase of his ideas using
> my own terms such as "incorrect questions".
>

And, until your provide the names and actual statements, this claim is
worth exactly NOTHING.

On 10/29/2023 8:19 PM, olcott wrote:
> On 10/29/2023 7:57 PM, olcott wrote:
>> On 10/29/2023 6:43 PM, olcott wrote:
>>> On 10/29/2023 5:38 PM, olcott wrote:
>>>> On 10/29/2023 3:58 PM, olcott wrote:
>>>>> On 10/29/2023 12:30 PM, olcott wrote:
>>>>>> *Everyone agrees that this is impossible*
>>>>>> No computer program H can correctly predict what another computer
>>>>>> program D will do when D has been programmed to do the opposite of
>>>>>> whatever H says.
>>>>>>
>>>>>> H(D) is functional notation that specifies the return value from H(D)
>>>>>> Correct(H(D)==false) means that H(D) is correct that D does not halt
>>>>>> Correct(H(D)==true) means that H(D) is correct that D does halt
>>>>>>
>>>>>> For all H ∈ TM there exists input D such that
>>>>>> (Correct(H(D)==false) ∨ (Correct(H(D)==true))==false
>>>>>>
>>>>>> *No one pays attention to what this impossibility means*
>>>>>> The halting problem is defined as an unsatisfiable specification thus
>>>>>> isomorphic to a question that has been defined to have no correct
>>>>>> answer.
>>>>>>
>>>>>> What time is it (yes or no)?
>>>>>> has no correct answer because there is something wrong with the
>>>>>> question. In this case we know to blame the question and not the one
>>>>>> answering it.
>>>>>>
>>>>>> When we understand that there are some inputs to every TM H that
>>>>>> contradict both Boolean return values that H could return then the
>>>>>> question: Does your input halt? is essentially a self-contradictory
>>>>>> (thus incorrect) question in these cases.
>>>>>>
>>>>>> The inability to correctly answer an incorrect question places no
>>>>>> actual
>>>>>> limit on anyone or anything.
>>>>>>
>>>>>> This insight opens up an alternative treatment of these pathological
>>>>>> inputs the same way that ZFC handled Russell's Paradox.
>>>>>>
>>>>>
>>>>> The halting problem proofs merely show that the problem
>>>>> definition is unsatisfiable because every H of the infinite
>>>>> set of all Turing Machines has an input that makes the
>>>>> question: Does your input halt? into a self-contradictory
>>>>> thus incorrect question for this H.
>>>>
>>>> I now have two University professors that agree with this.
>>>> My words may need some technical improvement...
>>>>
>>>> [problem specification] is unsatisfiable
>>>>
>>>> The idea is to convey the essence of many technical
>>>> papers in a single sound bite:
>>>>
>>>> *The halting problem proofs merely show that*
>>>> *self-contradictory questions have no correct answer*
>>>
>>>     Anonymous experts are not "evidence"
>>>     and no "expert" can contradict the
>>>     actual definitions.
>>>
>>> The whole thing is a matter of these definitions
>>> semantically entailing additional nuances of meaning
>>> that no one ever noticed before.
>>>
>>> Computer scientists almost never pay any attention
>>> at all to the philosophical underpinnings of the
>>> foundations of concepts such as undecidability.
>>>
>>> All of my related work in the last twenty years
>>> has focused on these foundational underpinnings.
>>>
>>
>> In the same way that incompleteness is proven whenever
>> any WFF of a formal system cannot be proven or refuted
>> in this formal system EVEN WHEN THE WFF IS SEMANTICALLY
>> SELF-CONTRADICTORY
>>
>> The notion of undecidability is determined even when the
>> decider is required to correctly answer a self-contradictory
>> (thus incorrect) question.
>>
>> This is the epiphany of my work for the last 20 years and
>> two professors agree that this does apply to the halting
>> problem specification.
>>
>
> I cannot form a proof on the basis of the conventional
> definitions because the issue is that one of these
> definitions semantically entails more meaning than
> anyone ever noticed before.
>
> That this applies generically to the notion of undecidability
> seems to be an extension of these sames ideas that these
> professors only applied to the halting problem specification.
>
> The lead of these two professors and I exchanged fifty emails
> where he confirmed my verbatim paraphrase of his ideas using
> my own terms such as "incorrect questions".
>

Then you are admtting that you can't do the
work in the formal system, so any claim you
make about anything IN the system is just invalid.

That the "term undecidability" semantically entails
previously unnoticed nuances of meaning can be understood
on the basis of the reasoning of myself and these two professors.

Just like incompleteness includes self-contradictory
expressions in its measure of incompleteness, undecidability
includes problem specifications that entail self-contradictory
questions. IF YOU WEREN'T STUCK IN REBUTTAL MODE YOU MIGHT SEE THIS

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