The Halting Problem is based on an ill-formed Question

[Peter Olcott]

If a yes or no question does not have a correct yes or no answer then
there must be something wrong with this question.

More generally:
An ill-formed question is defined as any question that lacks a correct
answer from the set of all possible answers.

The *only* reason that the self reference form of the Halting Problem
can not be solved is that neither of the two possible final states of
any potential halt decider TM corresponds to whether or not its input TM
will halt on its input.

In other words for potential
halt decider H and input M:
---------------------------
Not<ThereExists>
<ElementOfSet>
FinalStatesOf_H
<MathematicallyMapsTo>
Halts(M, H, input)

Where M is defined as
---------------------
M(String H, String input):
if H(input, H, input) loop
else halt

The only difference between asking a yes or no question and the
invocation of a Turing Machine is a natural language interface.

Within a natural language interface the invocation of H(M, H, M) would
be specified as:

“Does Turing Machine M halt on input of Turing Machine H
and Turing Machine M?”

Within a natural language interface the answer to this question would be
specified as “yes” or “no” and map to the final states of H of accept or
reject.

So the only reason that the self reference form of the Halting Problem
can not be solved is that it is based on a yes or no question that lacks
a correct yes or no answer, and thereby derives an ill-formed question.

[Graham Cooper]

On Jun 9, 11:43 am, Peter Olcott <OCR4Screen> wrote:
> If a yes or no question does not have a correct yes or no answer then
> there must be something wrong with this question.
>
> More generally:
> An ill-formed question is defined as any question that lacks a correct
> answer from the set of all possible answers.
>
> The *only* reason that the self reference form of the Halting Problem
> can not be solved is that neither of the two possible final states of
> any potential halt decider TM corresponds to whether or not its input TM
> will halt on its input.
>
> In other words for potential
> halt decider H and input M:
> ---------------------------
> Not<ThereExists>
> <ElementOfSet>
> FinalStatesOf_H
> <MathematicallyMapsTo>
> Halts(M, H, input)
>
> Where M is defined as
> ---------------------
> M(String H, String input):
> if H(input, H, input) loop
> else halt
>

You need to FULLY FORMALISE this problem to make a proper argument.

Have you seen STRIPS PLAN SPECIFICATION LANGUAGE?

http://en.wikipedia.org/wiki/STRIPS
STRIPS (Stanford Research Institute Problem Solver) is an automated
planner


A sample STRIPS problem

A monkey is at location A in a lab.
There is a box in location C.
The monkey wants the bananas that are hanging from the ceiling in
location B,
but it needs to move the box and climb onto it in order to reach them.

Initial state: At(A), Level(low), BoxAt(C), BananasAt(B)
Goal state: Have(Bananas)

Actions:
// move from X to Y
_Move(X, Y)_
Preconditions: At(X), Level(low)
Postconditions: not At(X), At(Y)

// climb up on the box
_ClimbUp(Location)_
Preconditions: At(Location), BoxAt(Location),
Level(low)
Postconditions: Level(high), not Level(low)

// climb down from the box
_ClimbDown(Location)_
Preconditions: At(Location), BoxAt(Location),
Level(high)
Postconditions: Level(low), not Level(high)

// move monkey and box from X to Y
_MoveBox(X, Y)_
Preconditions: At(X), BoxAt(X), Level(low)
Postconditions: BoxAt(Y), not BoxAt(X), At(Y), not
At(X)

// take the bananas
_TakeBananas(Location)_
Preconditions: At(Location), BananasAt(Location),
Level(high)
Postconditions: Have(bananas)


The Halt Proof conclusion definitely says NOTHING about a Halt
Function that works exclusively on a directed acyclic graph of
programs references within the Halt parameters.

e.g.
PROGRAM1 ... HALT(program2) ...
PROGRAM2 ... HALT(program3) ...
...
PROGRAMn-1 ... HALT(programn) ...
PROGRAMN ... HALT(program1)

This CYCLE is easy to avoid in languages such as ZFC, using Axiom Of
Regularity.

Herc

[cplxphil]

No one would say that instances of the halting problem lack a yes or
no answer. The issue, when one says "the halting problem 'cannot be
solved'" is that there is no Turing machine that accurately decides
the problem on every instance.

So yes--every instance either has an answer of "yes" or "no"--but not
every instance can be solved by a Turing machine.

It's not ill-formed--your "questions" have answers, they are just hard/
impossible to find.

Do you think that the question, "Is the answer to this question no?"
is ill-formed?

You've heard of Godel's Incompleteness Theorem, right? The Halting
Problem is rather similar.

[Peter Olcott]

Yes this point has been missed for many years.

Since the final states: {accept, reject} of H form the entire solution
set, (every possible answer that H can provide) and these states have
been shown to mathematically map to yes or no therefore the inability of
a Turing Machine to solve the halting problem is merely the inability to
correctly answer a yes or no question that has no correct yes or no answer.

> The issue, when one says "the halting problem 'cannot be
> solved'" is that there is no Turing machine that accurately decides
> the problem on every instance.
>
> So yes--every instance either has an answer of "yes" or "no"--but not
> every instance can be solved by a Turing machine.
>
> It's not ill-formed--your "questions" have answers, they are just hard/
> impossible to find.
>
> Do you think that the question, "Is the answer to this question no?"
> is ill-formed?

Yes.

> You've heard of Godel's Incompleteness Theorem, right? The Halting
> Problem is rather similar.

Yes, and Godel's Incompleteness Theorem errs for the same reason.

[Graham Cooper]

Well one could say Godel's Proof offers the SOLUTION METHOD to the
halting problem!

THEORY |- !PROOF(G)
GODEL |- PROOF( THEORY|-G )

SEPARATE THE PROGRAM FROM THE TEST HARNESS

PROGRAM1 |- PRINT "HELLO"
TESTHARNESS |- IF HALT(PROGRAM1) PRINT "P1 HALTS!"

**********************

Not only that, Godel tried to prove a FORMAL_DERIVATION
PROOF_PREDICATE was impossible to program!

DERIVABLE(THEOREM) <-> E(A) E(B) DERIVABLE(A) ^ DERIVABLE(B) ^ (A^B)-
>THEOREM

Now we have a FORMAL METHOD to prove such things as whether programs
Halt!


Herc

[Graham Cooper]

DERIVBLE(THRM) <-> E(A) E(B) DERIVBLE(A) ^ DERIVBLE(B) ^ (A^B)->THRM


^^^ FORMAL MATHEMATICS! IT'S TRIVIAL! ^^^

PROVE IF A PROGRAM HALTS!
PROVE WHO YOUR PATERNAL GRANDMA IS!

(G->A) ^ (D^B->C)
->
(G^D^A->B)->C
since G^(G->A)^(A->B) -> B *forward chaining
so now only D (and G..) are required to prove C

Backward chaining using PRV()
PRV(C) <-> C v PRV(D)^PRV(B)^(D^B->C)
PRV(D)^PRV(B)^(D^B->C) -> PRV(C) //since C is not yet shown true
PRV(D) <-> D v PRV(x)^PRV(y)^(x^y->D)
D -> PRV(D) //no other info about D
PRV(B) <-> B v PRV(A)^(A->B) //Unary PRV() formula
PRV(A) <-> A v PRV(G)^(G->A)
ASSUMEG -> G
G->PRV(G)
ASSUMEG ->
PRV(G)
PRV(A) <- PRV(G)^(G->A)
PRV(A) <- TRUE^(G->A)
PRV(A) <- (G->A)
PRV(A) <- TRUE
PRV(A)
PRV(B) <- PRV(A)^(A->B)
PRV(B) <- (A->B)
ASSUMEAImpliesB -> A->B
ASSUMEAImpliesB ->
PRV(B)
PRV(D)^PRV(B)^(D^B->C) -> PRV(C)
PRV(D)^(D^B->C) -> PRV(C)
PRV(D)->PRV(C)

i.e. Given (G->A) ^ (D^B->C)
ASSUME G, A->B, D to Prove C
QED






Herc
--
http://tinyurl.com/BLUEPRINTS-PROOF
http://tinyurl.com/BLUEPRINTS-LOGIC

[Ben Bacarisse]

Peter Olcott <OCR4Screen> writes:

> If a yes or no question does not have a correct yes or no answer then
> there must be something wrong with this question.

I was just thinking "surely there's not point reading this; can there be
anything new?" when low-and-behold it contains a *new* error:

<snip>

> In other words for potential
> halt decider H and input M:
> ---------------------------
> Not<ThereExists>
> <ElementOfSet>
> FinalStatesOf_H
> <MathematicallyMapsTo>
> Halts(M, H, input)
>
> Where M is defined as
> ---------------------
> M(String H, String input):
> if H(input, H, input) loop
> else halt
>
> The only difference between asking a yes or no question and the
> invocation of a Turing Machine is a natural language interface.
>
> Within a natural language interface the invocation of H(M, H, M) would
> be specified as:
>
> “Does Turing Machine M halt on input of Turing Machine H
> and Turing Machine M?”

No, it would be read as "What does the machine H say when invoked with
input (M, H, M)?". But that has a simple yes/no answer so it does not
fit with PO's preconceived idea of what the answer should be, so he has
to... er, "misrepresent the truth".

Misrepresenting the result of an invocation of a "potential halt
decider" as being a questions about whether a machine *actually* halts
or not is the error at core of all of the recent nonsense.

<snip>
--
Ben.

[Peter Olcott]

"Ben Bacarisse" <ben.u...@bsb.me.uk> wrote in message
news:0.0643db3d6f08e5c88d3b.2012...@bsb.me.uk...

Since you can not possibly construct the Halting Problem from the above
question, this proves that you are flatly incorrect. Since my version
precisely maps to the Halting Problem, this proves that I am correct.

[Graham Cooper]

You are incapable of comment except disdain.

Can you answer BEN!

Whether this program can be used to form an equivalent HALTING PROOF
to Turing's?

10 IF HALT() THEN GOTO 10

GEORGE GREEN HAS USED THIS VARIANT HIMSELF

but is quiet on the issue.

If you cannot even COMPREHEND BASIC TRIVIAL EQUIVALENT EXAMPLES that
are the BASIS OF THE IRREFLEXIVE SCOPE DEFINITION of the PRO-HALT()
ARGUMENT.. then why is your word worth the 200 bytes on nonsense you
occupy.

ANSWER THE QUESTION - NOT A AD HOM DODGE LIKE ALWAYS BEN!! BB()

Herc

[Graham Cooper]

On Jun 9, 11:55 am, Graham Cooper <grahamcoop...@gmail.com> wrote:
> On Jun 9, 11:43 am, Peter Olcott <OCR4Screen> wrote:
> > In other words for potential
> > halt decider H and input M:
> > ---------------------------
> > Not<ThereExists>
> > <ElementOfSet>
> > FinalStatesOf_H
> > <MathematicallyMapsTo>
> > Halts(M, H, input)
>
> > Where M is defined as
> > ---------------------
> > M(String H, String input):
> > if H(input, H, input) loop
> > else halt
>

PETER'S FORMAL STYLE IS REALLY CLOSE TO STRIPS

a set of operators (i.e., actions); each operator is itself a
quadruple , each element being a set of conditions.

These four sets specify, in order,
which conditions must be true for the action to be executable,
which ones must be false,
which ones are made true by the action and
which ones are made false;

like a TEMPORAL PREDICATE SEARCH PROCEDURE!!

Initial state: At(A), Level(low), BoxAt(C), BananasAt(B)
Goal state:    Have(Bananas)

Actions:
    // move from X to Y
   _Move(X, Y)_
   Preconditions:  At(X), Level(low)
     Postconditions: not At(X), At(Y)

     // take the bananas
     _TakeBananas(Location)_
     Preconditions:  At(Location), BananasAt(Location), Level(high)
     Postconditions: Have(bananas)

EG
THE FALSE POSTCONDITION of MOVE FROM X TO Y
is AT(X)
I.E. AFTER you move away from X, NOT(AT(X))

>
> e.g.
> PROGRAM1 ... HALT(program2) ...
> PROGRAM2 ... HALT(program3) ...
> ...
> PROGRAMn-1 ... HALT(programn) ...
> PROGRAMN ... HALT(program1)
>
> This CYCLE is easy to avoid in languages such as ZFC, using Axiom Of
> Regularity.
>

This LOGIC NEWSGROUP is ENTIRELY BOGUS when not one comment is made on
the above proposal to refine the domain of HALT(); and the subject is
dismissed with AD HOMS instead.

Herc

[cplxphil]

Perhaps you've been over this before in your lengthy discussions, but
let me see if I have this straight.

You are saying that the question, "Does machine M halt on input I?"
may, for certain M and I, be impossible to answer either yes or no?

If it doesn't either halt or not halt on input I, what exactly does it
do?

Also, before this continues too long: It sounds like you are quite
confident that you're right about this. I am quite confident that you
are not. What would it take to convince you that you are wrong?

For my part, I will be satisfied and agree that Turing's result is
somehow wrong if you can implement an algorithm that solves the
halting problem. If you are going to say that the Halting problem is
ill-formed, then in order for me to agree with this, I would need to
see an example of a machine that both fails to halt and fails to not
halt. (Good luck.)

[Graham Cooper]

On Jun 10, 8:58 am, cplxphil <cplxp...@gmail.com> wrote:
>
> You are saying that the question, "Does machine M halt on input I?"
> may, for certain M and I, be impossible to answer either yes or no?
>

BINGO!!!! THAT IS YOUR HALTING PROOF!

[N]

Hi!

yes and who's climbing with those bananas too

[Joshua Cranmer]

On 6/9/2012 6:58 PM, cplxphil wrote:
> Perhaps you've been over this before in your lengthy discussions, but
> let me see if I have this straight.
>
> You are saying that the question, "Does machine M halt on input I?"
> may, for certain M and I, be impossible to answer either yes or no?

I think Peter believes that this is not the proper way to phrase the
question really being asked. Although, when he was pushed into a corner,
I think there was a tacit admission that the answer of such a question
depends on who you asking it of.

> Also, before this continues too long: It sounds like you are quite
> confident that you're right about this. I am quite confident that you
> are not. What would it take to convince you that you are wrong?

Again, I think the answer is that he has no issue with proof, per se.
His umbrage is with the interpretation of the result: he believes that
it is possible to make a Halt decider that is "essentially" correct but
fails in some cases which are "necessary" (use of quotation marks to
indicate that the terms contained within are slippery and ill-defined).
Lots of people have attempted to illustrate several alternate
derivations to show that the incorrectness is not so well-contained, but
they have all been ignored because either:
a) it happens to fall under the "necessary" failures,
b) it relies on a similar "incorrect" result (the uncountability of real
numbers and Godel's incompleteness theorem have also been explicitly
cited as incorrect proofs due to being similar [1]), or
c) he doesn't understand it, so it has to be either case a or case b
because he is OBVIOUSLY right.

Trying to come up with a simple, alternate proof of the Halting problem
that is understandable and skirts any other proofs that have anything
smacking of diagonalization or self-reference is indeed hard, but I
doubt he'd accept anything less. I also doubt that he'd accept even that
much, though...

[1] This just makes it seem to me that he has a really hard time
accepting that a proof by contradiction is indeed a valid proof.

--
Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth

[Graham Cooper]

On Jun 10, 11:39 am, Joshua Cranmer <Pidgeo...@verizon.invalid> wrote:
> [1] This just makes it seem to me that he has a really hard time
> accepting that a proof by contradiction is indeed a valid proof.

... of the negation of your hypothesis.

The following is the same form as The Halt Proof.

ASSUME a function exists that is irreflexive (i.e. tests OTHER
functions) and works on all possible values.

f(f) = NO VALUE

CONTRADICTION

... BULLSHIT FOLLOWS FROM DISPROOF OF INVALID HYPOTHESIS

Herc

--
P: If Halts(P) Then Loop Else Halt.
is obviously a paradoxical program if Halts() exists.
BUT IF IT WEREN'T NAMED P then it might not be:
Q: If Halts(P) Then Loop Else Halt.
is NOT paradoxical.
~ George Green (sci.logic)

[Peter Olcott]

The input to H, either halts or does not halt, depending upon how H is
defined.

The Halting problem is based on an ill-formed question because neither
answer of every possible answer that H can provide (by transitioning to
its own accept or reject state) mathematically maps to whether or not
the input to H halts on its input.

> Also, before this continues too long: It sounds like you are quite
> confident that you're right about this. I am quite confident that you
> are not. What would it take to convince you that you are wrong?

I will carefully examine every line-of-reasoning that attempts to show
that my reasoning is incorrect. I will point out any errors that I find.

[Peter Olcott]

On 6/9/2012 8:39 PM, Joshua Cranmer wrote:
> On 6/9/2012 6:58 PM, cplxphil wrote:
>> Perhaps you've been over this before in your lengthy discussions, but
>> let me see if I have this straight.
>>
>> You are saying that the question, "Does machine M halt on input I?"
>> may, for certain M and I, be impossible to answer either yes or no?
>
> I think Peter believes that this is not the proper way to phrase the
> question really being asked. Although, when he was pushed into a
> corner, I think there was a tacit admission that the answer of such a
> question depends on who you asking it of.
>

When the question is asked of the entire set of every potential halt
decider, and every element of this set is limited to providing its
answer by transitioning to one of its own final states of {accept,
reject} then this question derives a yes or no question that lacks a
correct yes or no answer and is thereby ill-formed.

Not<ThereExists>
<ElementOfSet>
FinalStatesOf_H
<MathematicallyMapsTo>
Halts(M, H, input)

Where M is defined as
---------------------
M(String H, String input):
if H(input, H, input) loop
else halt

[William Elliot]

On Fri, 8 Jun 2012, Peter Olcott wrote:

> If a yes or no question does not have a correct yes or no answer then there
> must be something wrong with this question.
>

Nonsense. "Guilty or not guilty?" and the trial ends with a hung jury.

> More generally:
> An ill-formed question is defined as any question that lacks a correct answer
> from the set of all possible answers.

Therefore don't ask any research or philosophical questions that can't be
answered or any question with a statistical answer such as "maybe".

[George Greene]

On Jun 8, 9:43 pm, Peter Olcott <OCR4Screen> wrote:

> If a yes or no question does not have a correct yes or no answer then
> there must be something wrong with this question.

But if it is a yes or no question then you CANNOT SAY that the answer
has to come from some set other than the set {yes,no}.
Which you HAVE been doing routinely. You have been asking a question
whose answer has to be a number and then
claiming that it is ill-formed because you have (impossibly) added a
FURTHER (non-existent) constraint that it ALSO be
a color. Or something.

> More generally:
> An ill-formed question is defined as any question that lacks a correct
> answer from the set of all possible answers.

The set of possible answers is determined by the TYPE of the relevant
interrogative term in the question, NOT by some OTHER set that you
(impossibly) try to tack on afterwards as a constraint.

>
> The *only* reason that the self reference form of the Halting Problem
> can not be solved is that neither of the two possible final states of
> any potential halt decider TM corresponds to whether or not its input TM
> will halt on its input.

This is NOT the case.
You canNOT ask a SUBTRACTION question of an ADDITION tm. The KIND of
question that can be posed to a tm DEPENDS ON THE KIND OF TM it is.
It depends on what the TM is programmed to do. If the TM is NOT A
HALTS TM then it CANNOT BE ASKED a halting question.
And since NO tm is a Halts TM, NO tm can be asked a halting question
IN THE GENERAL CASE. Now, of course, there are plenty
of TMs that correctly decide halting questions for some simplified
subdomain of all TMs. But there simply isn't one in the general case.
Posing a question to a subdomain/halting TM, when the input IS OUTSIDE
THE SUBDOMAIN over which the TM is known/programmed/specified to
answer halting questions, might or might not be "ill-formed" but the
point is, the TM was NOT DESIGNED OR PROGRAMMED to answer questions
outside its subdomain AT ALL,
so whatEVER happens, that happening (as an output) CANNOT BE
"incorrect".
In point of actual fact, NO behavior OF ANY tm IS EVER incorrect, nor
CAN it be incorrect.

> In other words for potential
> halt decider H and input M:

There is no such thing as a potential halt decider.
No machine IS EVER a halt decider in the general case, NOT EVEN
POTENTIALLY.
The fact that you WANT a machine to be a halt decider IS NEVER ANY
SORT OF CONSTRAINT whatsoever on the behavior of the machine,
"correct" or otherwise.

[George Greene]

> "Ben Bacarisse" <ben.use...@bsb.me.uk> wrote in message

> > No, it would be read as "What does the machine H say when invoked with
> > input (M, H, M)?".

On Jun 9, 2:28 pm, "Peter Olcott" <NoS...@OCR4Screen.com> wrote:
> Since you can not possibly construct the Halting Problem from the above
> question,

You're LYING, Peter. The Halting Problem is constructed IN ENGLISH.
It is "can you construct a TM that tells whether a TM halts on an
input?"
It does not need to be "constructed from" ANY question. The question
that Ben
has posed,

> > "What does the machine H say when invoked with
> > input (M, H, M)?".

is AN INSTANCE of the Halting problem, NOT something from which anyone
could ever even need TO TRY to "construct" the Halting problem.
The halting problem is "constructed" JUST BY ASKING THE QUESTION. The
problem is to determine whether something does or doesn't exist.
The only relevant construction would be the construction of a Halts
TM. Since the mere EXISTENCE of such a TM would entail a
contradiction,
there is CERTAINLY no point in anybody's bothering to try to CONSTRUCT
one. As for constructing the problem, I repeat, MERELY ASKING THE
QUESTION *is* constructing the PROBLEM; the problem IS a question -- a
question about the [non-]existence of a TM having certain properties.
No TM has that collection of properties.

[George Greene]

On Jun 9, 10:41 am, Ben Bacarisse <ben.use...@bsb.me.uk> wrote:
> Misrepresenting the result of an invocation of a "potential halt

> decider" as being a question about whether a machine *actually* halts

> or not is the error at core of all of the recent nonsense.

Of course it is. You can ONLY pose a "does it halt?" question TO a
Halts TM.
Since no such thing as a Halts TM exists, no matter WHAT TM you are
invoking,
you are NEVER ASKING THAT question. Unless, of course, you have
specifically
chosen to limit the inputs to some finite level of complexity and
length of input.
Then the whole problem is finitary and of course you can write a TM
that correctly
answers all the halting questions IN ITS SIMPLIFIED SUBDOMAIN.
This will of course have exactly ZERO relevance to "the" halting
problem since "the"
halting problem was the problem of designing a TM that gave the
correct answer for ALL TMs
(including itself) on ALL inputs.

[George Greene]

On Jun 9, 11:43 pm, Peter Olcott <OCR4Screen> wrote:
> When the question is asked of the entire set of every potential halt
> decider

THAT would be NEVER.
THERE ARE NO Potential Halt Deciders.
From your standpoint, EVERY LAST TM ON EARTH would be a potential halt
decider.
From everybody else's, NO TM is a potential halt decider because THEY
ALL FAIL.
They don't just potentially fail, they factually fail. And NOT A ONE
of them has ANY POTENTIAL WHATSOEVER
for EVER becoming a halt decider.

[Joshua Cranmer]

So, in other words, it is impossible to convince that you are wrong.

[Peter Olcott]

"Joshua Cranmer" <Pidg...@verizon.invalid> wrote in message
news:jr23h2$hil$1...@dont-email.me...

> On 6/9/2012 11:32 PM, Peter Olcott wrote:
>> On 6/9/2012 5:58 PM, cplxphil wrote:
>>> Also, before this continues too long: It sounds like you are quite
>>> confident that you're right about this. I am quite confident that you
>>> are not. What would it take to convince you that you are wrong?
>> I will carefully examine every line-of-reasoning that attempts to show
>> that my reasoning is incorrect. I will point out any errors that I find.
>
> So, in other words, it is impossible to convince that you are wrong.

It would be impossible to convince me that I am wrong if I am *not* wrong,
otherwise it is possible.
So far I have not seen anything resembling sound reasoning that correctly
refutes my true position.
I have made very many errors in presenting this position, and from what I
can tell most of these have been corrected.

Since my goal is to provide this reasoning using English that is 100%
completely mathematically precisely correct, George may have pointed out a
recent error. It may have been incorrect for me to use the term "potential
halt decider".
When I used this term I was referring to any Turing Machine that attempts to
be a halt decider, even though none could ever actually achieve this. Since
none could ever actually achieve this, no actual potential exists.

Here is a possibly better statement of my position:

The reason why the self reference form of the Halting Problem can not be
solved is:
1) The invocation of every Turing Machine that attempts to be a halt decider
mathematically maps to a yes or no question (within a natural language
interface).

2) The yes or no answer to this question that this set of Turing Machines
can possibly provide (within a natural language interface) mathematically
maps to its own final states of accept and reject, thus deriving the entire
solution set of every possible answer.

3) Neither of these yes or no (accept or reject) answers is correct
(mathematically maps to whether or not the input TM will halt on its input).

4) Therefore the reason that the self reference form of the Halting Problem
can not be solved is that this problem is based on providing a yes or no
answer to a question that has no correct yes or no answer.

Any attempted refutation should provide reasoning that refutes the above
points individually. Stating that the above reasoning is nonsense merely
indicates a failure of the respondent to comprehend and nothing more.

[George Greene]

On Jun 10, 10:21 am, "Peter Olcott" <NoS...@OCR4Screen.com> wrote:
> Here is a possibly better statement of my position:
>
> The reason why the self reference form of the Halting Problem can not be
> solved is:

Well, THERE'S YOUR TROUBLE. There IS NO SUCH THING AS "the self-
reference form of" the halting problem.
THE halting problem is called THE halting problem BECAUSE IT IS
UNIQUE. It ONLY HAS ONE form! It is in the form of AN EXISTENCE
question. It is in the form, "DOES THERE EXIST A TM" with a certain
property, namely, the property that, when it interprets its finite
input string as a finite specification or finite code-string for a TM,
AND (concatenated with) a finite input string for that TM, DOES THIS
(existent) TM ALWAYS RETURN The truth value of "the TM specified by
the code-string halts on the input-string that is the rest of the
input". Well, does it? CAN there even exist such a TM? THAT IS THE
ONLY form of THE halting problem.

[Daryl McCullough]

I see that this channel has started showing repeats, so
I'll go watch something else.

[Graham Cooper]

Right! and the method to show it cannot exist is the self reference
case.

Herc

--
P: If Halts(P) Then Loop Else Halt.
is obviously a paradoxical program if Halts() exists.

BUT IF IT WEREN'T NAMED P then it might not be:
Q: If Halts(P) Then Loop Else Halt.
is NOT paradoxical.

~ GEORGE GREEN (sci.logic)

[cplxphil]

On Jun 10, 10:21 am, "Peter Olcott" <NoS...@OCR4Screen.com> wrote:

> "Joshua Cranmer" <Pidgeo...@verizon.invalid> wrote in message

I think I see what you're getting at.

Let's see if I can translate (into terms I'm comfortable with) and
then refute your 4 points:

1 > A Turing machine that could solve the halting problem must map to
a yes or no question.
2 > Such a Turing machine can only ever accept or reject.
3 > Neither answer to a "yes or no" halting question is correct.
(justification?)
4 > The halting problem has no answer.

Although I don't understand #3, the problem is with #1. You suggest,
"a halt decider...maps to a yes or no question." Yes, but only if it
works! Every "potential halt decider" we can develop *fails to halt*
when given a sufficiently problematic instance of the halting
problem. You are essentially starting out your argument by assuming
that the halting problem can be decided properly, which it cannot.

You are saying that every Turing machine must, via a natural language
interface (which--by the way--technically has no place in a
mathematical argument), map to a natural language question. Wrong!
The mathematical *question* that you discuss must map to a yes or no
question, but a Turing machine is a computer program and a
mathematical object--and thus is not governed by your beliefs about
natural language.

The irony of your argument is that a modification of it actually
suggests that Turing's result is correct. In fact, if Turing's result
were wrong, you would be correct. Logically speaking, if you could
establish something as logically contradictory as the actual existence
of a "potential halt decider," you would be able to prove anything--
even that the moon is made of cheese.

Moons made of cheese are neither here nor there, but in summary, your
fallacy is the claim that the *Turing machine* must map to a yes or no
question. A Turing machine is free to do whatever it wants, including
never halt, even if you would like it to be a potential halt decider.

Ironically, your step #1 represents a contradiction that Turing
exploits in his proof. You are assuming that the halt decider exists,
and that it maps to a yes or no question. That is precisely what
Turing assumes--and using that false assumption and some self-
reference tricks, he produces precisely the result that you claim
doesn't make sense.

I've been a bit repetitive above, mainly for emphasis (and out of
laziness), but I hope I've made my point. One last time: A Turing
machine does not map to a yes or no question, it maps to "yes, no,
never halt."

I have a sinking feeling you won't be convinced....

[Graham Cooper]

On Jun 11, 10:26 am, cplxphil <cplxp...@gmail.com> wrote:
>
> 1 > A Turing machine that could solve the halting problem must map to
> a yes or no question.
> 2 > Such a Turing machine can only ever accept or reject.
> 3 > Neither answer to a "yes or no" halting question is correct.
> (justification?)

SEE
www.tinyurl.com/BLUEPRINTS-HALT

fot the 3rd option

Herc

[George Greene]

On Jun 10, 8:14 pm, Graham Cooper <grahamcoop...@gmail.com> wrote:
> Right!  and the method to show it cannot exist is the self reference case.

This method is not unique. There is no such thing as "the" method
here.
This is just the most obvious method. If something in fact cannot
exist then
the necessarily&provably- false assumption that it does, like ANY
provably false assumption,
NECESSARILY BEGETS MYRIAD absurdities as consequences. Other proofs
are possible
but as yet we have no motivation to go there because P.O. refuses to
stop lying about this one.

>
> Herc
>
> --
> P: If Halts(P) Then Loop Else Halt.
> is obviously a paradoxical program if Halts() exists.
>
> BUT IF IT WEREN'T NAMED P then it might not be:
> Q: If Halts(P) Then Loop Else Halt.
> is NOT paradoxical.

Well, it's not paradoxical as long as Q has a different output from P
on SOME input-string.

[George Greene]

On Jun 10, 10:21 am, "Peter Olcott" <NoS...@OCR4Screen.com> wrote:

> It would be impossible to convince me that I am wrong if I am *not* wrong,
> otherwise it is possible.

Liar.

> So far I have not seen anything resembling sound reasoning that correctly
> refutes my true position.

Liar. You have seen sound reasoning showing you that there cannot
exist ANY h that bears ANY binary relation R to all and only those x's
that do not bear R to themselves. You have seen that there is nothing
ill-formed in that reasoning. Yet you persist in continuing to think
that there is something ill-formed about non-
existence claims following from this fact. If there were a TM that
could decide halting in the general case, then you have seen sound
reasoning showing that there
would then LOGICALLY, NECESSARILY, ALSO exist a TM halting on all and
only those TMs that halted on their OWN code-strings as input-
strings. Since the mere existence of THAT tm is a logical
impossibility, sound reasoning implies that the existence of a halt-
deciding TM is also a logical impossibility. Yet you persist in
claiming that (falsely) that there is some sort of "question" in this
chain of reasoning (there is not) and that the question is "ill-
formed". Well, to the extent that the question is about something
that cannot exist, maybe THAT question is ill-formed, but the PRIOR
question of WHETHER this thing (a halts TM) exists IS NOT ill-formed;
the answer is just clearly, logically, "No, it doesn't exist".

[Joshua Cranmer]

On 6/10/2012 10:21 AM, Peter Olcott wrote:
> It would be impossible to convince me that I am wrong if I am *not* wrong,
> otherwise it is possible.

I can't think of a nice sugar-coated way to say this, so I'll be blunt:
you're taking an egotistical approach to proofs, in that you are by
default infallible until something is proved wrong. This is not a good
approach to theorem proving; instead, you should attempt to attack your
own proofs as much as possible and wait to see if you still see it
holding after a barrage.

> So far I have not seen anything resembling sound reasoning that correctly
> refutes my true position.

I would posit that this is because you cannot see sound reasoning in the
first place :-P.

> I have made very many errors in presenting this position, and from what I
> can tell most of these have been corrected.

Er... no. You're still exuding extremely elementary errors.

> Since my goal is to provide this reasoning using English that is 100%
> completely mathematically precisely correct, George may have pointed out a
> recent error. It may have been incorrect for me to use the term "potential
> halt decider".

Starting with the biggest one of all: your proofs are in effect using
English terminology to anthropomorphize Turing machines. This results in
all of your proof attempts amounting to extremely vague things which are
somewhere between vacuously true and hopelessly wrong, since your
interpretation colors what you think it actually means. Add in your
nondesire to consider the notion that your proofs are actually rubbish,
and you result in non sequiturs that can't be argued against since no
one has any clue what you are saying.

> 1) The invocation of every Turing Machine that attempts to be a halt decider
> mathematically maps to a yes or no question (within a natural language
> interface).

One line into your proof and you've already shot your argument in the
foot. What does it mean for a Turing machine to "attempt to be"
something? This isn't a small nitpick: it completely determines the
class of machines you are discussing, which has a major impact on
argumentation against your proof.

It's also the kind of language which has absolutely no business being in
anything that resembles serious scholarly writing, or even armchair
introductions. No, it's the kind of language which is only suited for
things like TRON or ReBoot, where machines are actually anthropomorphized.

Your parenthetical note is also ambiguous, since you never clarify what
a "natural language interface" is.

> 2) The yes or no answer to this question that this set of Turing Machines
> can possibly provide (within a natural language interface) mathematically
> maps to its own final states of accept and reject, thus deriving the entire
> solution set of every possible answer.

The above note about ambiguous parenthetical notes remains true here as
well. Otherwise, everything up to the comma is more or less correct, but
it's missing something. What you have is not a surjective mapping, so
what is meant by a Turing machine that fails to halt is not clear. This
makes a logical interpretation of the phrase following the comma
incorrect. Of course, that phrase has several possible logical
interpretations, so you're sure as hell not being precise.

> 3) Neither of these yes or no (accept or reject) answers is correct
> (mathematically maps to whether or not the input TM will halt on its input).

And this is where you fall down. Let me list the sins in no particular
order:
1. Going straight from generalization to specialization without
describing context.
2. Stating the core of your argument without proof
3. Eschewing definitions.
4. Why? You never provide anything that smacks of answer to "why?"

> 4) Therefore the reason that the self reference form of the Halting Problem
> can not be solved is that this problem is based on providing a yes or no
> answer to a question that has no correct yes or no answer.

Attacking this individually is pointless, since you fall apart so badly
at #3 that all the problems here are a continuation of the confusion
resulting from the previous step.

> Any attempted refutation should provide reasoning that refutes the above
> points individually. Stating that the above reasoning is nonsense merely
> indicates a failure of the respondent to comprehend and nothing more.

Sometimes, the failure of a listener to understand isn't because the
listener can't comprehend but because the speaker can't explain. And
when you consider that no fewer than a dozen people have attempted to
understand your proofs and come out feeling that they are nonsense, a
basic application of Occam's Razor suggests that maybe the problem isn't
that everyone else in this channel are idiots who can't understand your
ethereal glory but maybe that you are someone who can't explain yourself
to everybody else.

Let me put it in another, simpler way that I hope you will understand.
Your logical argument is roughly equivalent to the following:

1. <Insert contemporary dictator here> is evil [Fact stated as "obvious"
which actually relies on a mixture of subjectivity and the particular
definition of a word]
2. Evil people should never be in power, so <insert contemporary
dictator here> shouldn't have been in power.
3. Democracy did it. [Wait what? Where did this come from?]
4. Therefore, democracy is a bad form of government.

That's kind of the feeling I get when I try to understand your proofs.
You make extraordinary claims and never give any strong justification
for them--extraordinary claims require extraordinary evidence. There was
one ... personality I knew who rejected any argument against his proofs
unless it was 100% completely watertight and explicit; any sketch of a
counterexample wouldn't be accepted. Yet you go further and reject any
argument that you can't understand.

[Graham Cooper]

On Jun 11, 10:51 am, George Greene <gree...@email.unc.edu> wrote:
> On Jun 10, 8:14 pm, Graham Cooper <grahamcoop...@gmail.com> wrote:
>
> > Right!  and the method to show it cannot exist is the self reference  case.
>
> This method is not unique.  There is no such thing as "the" method
> here.
> This is just the most obvious method.  If something in fact cannot
> exist then
> the necessarily&provably- false assumption that it does, like ANY
> provably false assumption,
> NECESSARILY BEGETS MYRIAD absurdities as consequences.  Other proofs
> are possible
> but as yet we have no motivation to go there because P.O. refuses to
> stop lying about this one.

Oh wake up George, you're 1,000,000 times smarter than this!

HALT is the FOUNDATION OF ALL ERROR.

CANTOR - wrong
GODEL - wrong
TARSKI - wrong
...
...

>
>
>
> > Herc
>
> > --
> > P: If Halts(P) Then Loop Else Halt.
> > is obviously a paradoxical program if Halts() exists.
>
> > BUT IF IT WEREN'T NAMED P then it might not be:
> > Q: If Halts(P) Then Loop Else Halt.
> > is NOT paradoxical.
>
> Well, it's not paradoxical as long as Q has a different output from P
> on SOME input-string.

Just separate the TEST HARNESS from the TEST PROGRAM.

There is no sequence beginning with f1..

HALT(f2) ... HALT(f3) ... HALT(fn) .. HALT(f1)

Don't you know what a function parameter STACK is?

Do *I* have to model what goes on the STACK when you do your silly
counterarguments?

Herc

[Ben Bacarisse]

Joshua Cranmer <Pidg...@verizon.invalid> writes:

> On 6/10/2012 10:21 AM, Peter Olcott wrote:
>> It would be impossible to convince me that I am wrong if I am *not* wrong,
>> otherwise it is possible.
>
> I can't think of a nice sugar-coated way to say this, so I'll be
> blunt: you're taking an egotistical approach to proofs, in that you
> are by default infallible until something is proved wrong.

And long after! I, too, think being blunt is worthwhile here. Peter
has no interest persuading anyone (how could the agreement of someone
with inferior reasoning skill be of any benefit to him?). What he needs
is to be engaged with -- to be part of an academic community that
discusses deep matters. Of course, his points are rather trivial, but
we can't refute them (in his mind) so they must be deep. It's a form of
"teach the controversy" for halting -- there is controversy so long as
the person making the silly claims says that there is.

I have no problem pointing out errors, but I've long ago decided that
debate is either impossible or pointless.

<snip>

>> I have made very many errors in presenting this position, and from what I
>> can tell most of these have been corrected.
>
> Er... no. You're still exuding extremely elementary errors.

I went to Google groups to try to find the start of this long series of
threads to see how far things had moved on, and I concluded that they
had not. I was a little surprised that I did not remember the exact
details but all the elements were there -- it's all due to ill-formed
questions, "malignant" self-reference, and so on.

Then I saw the date: 2006.

There are similar posts in 2004, and in 2012 he told us he'd actually
acquired some books about this subject. Given the history, that seems
like an uncharacteristically humble thing to do. Maybe the next set of
threads in 2014 will include a formal statement of the problem.

<snip>
--
Ben.

[Graham Cooper]

On Jun 11, 10:23 pm, Ben Bacarisse <ben.use...@bsb.me.uk> wrote:
> like an uncharacteristically humble thing to do.  Maybe the next set of
> threads in 2014 will include a formal statement of the problem.
>

> --
> Ben.

This sounds like a good starting block! Without specifically using
TMs,

LET ITHALTS be a property of all <function, argument> tuples.

HYPOTHESIS 0
THE HALTING PROOF SHOWS THAT THE FUNCTION HALT() IS UNCOMPUTABLE

HYPOTHESIS 1
THE HALTING PROOF SHOWS THAT THE FUNCTION HALT() DOMAIN IS NOT OVER
ALL <FUNCTION, ARGUMENT> TUPLES.


Discuss, brainstorm, further HYPOTHESES!

Herc
--
http://tinyurl.com/BLUEPRINTS-HALT

[Peter Olcott]

That would be an incorrect paraphrase.

I think that I am beginning to see why people are not understanding me.
There is a completely different point of view between the timing of
intentions of a software engineer and a mathematician.

Software engineers start with a problem to be solved, and from this
devise a specification, and then translate this specification into an
implementation. From this point of view deriving a Turing Machine that
solves the Halting Problem derives an ill-formed question.

Mathematicians examine the set of all finite length string
implementations (skipping the first two steps) and find than none of
these derive a Halting Decider, thus the mathematician never asks the
ill-formed question.

[cplxphil]

Argh...you say that my paraphrase is incorrect, but then don't try to
supply examples of a better one!

If your prose were precise and clear, it would be reasonable to just
say "oh that's wrong," but given that it clearly isn't, why not take a
little time to improve your exposition? You are not uncivil, but you
come across as a bit arrogant. I say this in the spirit of trying to
be constructive, not an effort to be vindictive or criticize you in an
ad hominem fashion.

Why not work on some clearer definitions? If you have the world's
most brilliant philosophical point in the world, but can't make it
clearly, you might as well be speaking Portuguese to a room full of
non-speakers. I suspect that if you have something of value to say,
it's disguised in your exposition to the point that you are wasting
your time trying to get anyone to understand it.

If you are going to keep posting to the same group over and over with
the same point, I for one won't try to stop you. But you would likely
make more progress if you clarified your definitions, phrased your
points as questions rather than groundbreaking discoveries, or sought
guidance from someone who understands your argument on how to make it
clearer.

[Graham Cooper]

HOW MUCH CLEARER DO YOU NEED IT?

HYPOTHESIS 0
THE HALTING PROOF SHOWS THAT THE FUNCTION HALT() IS UNCOMPUTABLE

HYPOTHESIS 1
THE HALTING PROOF SHOWS THAT THE FUNCTION HALT() DOMAIN IS NOT OVER
ALL <FUNCTION, ARGUMENT> TUPLES

Peter's proposal is the FINAL STATE TRANSITION of the HALT TM FINISHES
by outputting 1 on the tape for IT-HALTS and 0 for IT-HANGS

This is the DEFINITION OF SCOPE OF THE HALT TM - since it is designed
as a TEST HARNESS.

Feel free to comment on the discussion so far!

Herc
--
P: If Halts(P) Then Loop Else Halt.
is obviously a paradoxical program if Halts() exists.

BUT IF IT WEREN'T NAMED P then it might not be:

Q: If Halts(P) Then Loop Else Halt.
is NOT paradoxical.

~ GEORGE GREEN (sci.logic)

[Patricia Shanahan]

On 6/11/2012 6:04 PM, Peter Olcott wrote:

> I think that I am beginning to see why people are not understanding me.
> There is a completely different point of view between the timing of
> intentions of a software engineer and a mathematician.

This seems to suggest that you think only mathematicians disagree with
you and software engineers would agree. That is totally incorrect.

I am far better educated and more experienced as a software engineer
than as a mathematician.

Nothing in my education or experience as a software engineer supports
arbitrarily assuming an algorithm exists and is correct, and then
calling all the cases it gets wrong "ill-formed questions".

Patricia

[Graham Cooper]

On Jun 12, 6:18 pm, Patricia Shanahan <p...@acm.org> wrote:
>
> Nothing in my education or experience as a software engineer supports
> arbitrarily assuming an algorithm exists and is correct, and then
> calling all the cases it gets wrong "ill-formed questions".
>
> Patricia

If your Question is DOES THE ALGORITHM WORK ON ALL INPUT PAIRS?

then what would you call that question considering there are cases it
gets wrong?


Herc

[Peter Olcott]

"Patricia Shanahan" <pa...@acm.org> wrote in message
news:rrOdnZsg-fr-ZkvS...@earthlink.com...

Try applying Montague Grammar to the Liar Paradox and see where you get.

[Leif Roar Moldskred]

In comp.theory Graham Cooper <graham...@gmail.com> wrote:
>
> If your Question is DOES THE ALGORITHM WORK ON ALL INPUT PAIRS?
>
> then what would you call that question considering there are cases it
> gets wrong?

"Answered."

--
Leif Roar Moldskred

[Patricia Shanahan]

This seems like the obvious, and obviously correct, answer.

Even a single input pair for which the algorithm gets a wrong answer or
fails to terminate is sufficient to prove the answer is "No.".

There is one relevant difference between my mathematician and my
software engineer opinions. With my mathematician hat on, I am prepared
to consider the possibility of a proof that an algorithm exists that
does not involved exhibiting the algorithm and proving it correct. As a
software engineer, I would have no use for a proof that an algorithm
exists unless it tells me what the algorithm is, and why the algorithm
always works.

Patricia

[Graham Cooper]

On Jun 13, 6:46 am, Patricia Shanahan <p...@acm.org> wrote:
> On 6/12/2012 9:13 AM, Leif Roar Moldskred wrote:
>

> > In comp.theory Graham Cooper<grahamcoop...@gmail.com>  wrote:

>
> >> If your Question is DOES THE ALGORITHM WORK ON ALL INPUT PAIRS?
>
> >> then what would you call that question considering there are cases it
> >> gets wrong?
>
> > "Answered."
>
> This seems like the obvious, and obviously correct, answer.
>
> Even a single input pair for which the algorithm gets a wrong answer or
> fails to terminate is sufficient to prove the answer is "No.".

So the function 1/X is also UnComputable??

The input value X=0 the algorithm gets a wrong answer or fails,

this is sufficient to prove the answer is "No".

QUESTION: DOES THE ALGORITHM WORK ON ALL INPUTS?



Herc
--
?? - Now watch Patricia fail to answer My Question in this very post!

[Patricia Shanahan]

On 6/12/2012 2:12 PM, Graham Cooper wrote:
> On Jun 13, 6:46 am, Patricia Shanahan <p...@acm.org> wrote:
>> On 6/12/2012 9:13 AM, Leif Roar Moldskred wrote:
>>
>>> In comp.theory Graham Cooper<grahamcoop...@gmail.com> wrote:
>>
>>>> If your Question is DOES THE ALGORITHM WORK ON ALL INPUT PAIRS?
>>
>>>> then what would you call that question considering there are cases it
>>>> gets wrong?
>>
>>> "Answered."
>>
>> This seems like the obvious, and obviously correct, answer.
>>
>> Even a single input pair for which the algorithm gets a wrong answer or
>> fails to terminate is sufficient to prove the answer is "No.".
>
>
> So the function 1/X is also UnComputable??

Before we can discuss computability of a function, we need a fully
defined function. What is the domain? If 0 is in the domain, what is the
value of 1/0?

Patricia

[George Greene]

On Jun 8, 9:43 pm, Peter Olcott <OCR4Screen> wrote:
> Within a natural language interface the invocation of H(M, H, M) would
> be specified as:
>
> “Does Turing Machine M halt on input of Turing Machine H
> and Turing Machine M?”


NO, IT WOULDN'T. In order to ask "Does [whatever] Halt?", you have to
ask that question OF a TM
that IS PROGRAMMED TO ANSWER HALTING QUESTIONS.
If you want to ask "What is 5 -3 ?", you have to ask A SUBTRACTION
tm. Asking an ADDITION tm
or a MULTIPLICATION tm WILL NOT CONSTITUTE asking THAT question!

Since NO TM is a Halts TM, you cannot ask unbounded/large/GENERAL
halting questions OF ANY tm.

[Graham Cooper]

Just ASSUME A TM EXISTS that computes 1/X for all values of X.

This is YOUR LOGIC:

ALL FUNCTIONS HALT OR THEY DON'T HALT (1 OR 0)
->
A HALT DECIDER MUST WORK ON ALL INPUTS (ALL FUNCTIONS)
and answer in the range (1 OR 0)

...even though Halt() itself has no need to test if it itself halts.
...just like INVERSE(x) has no need to compute INVERSE(0)


Herc

[Graham Cooper]

On Jun 13, 9:26 am, George Greene <gree...@email.unc.edu> wrote:
> Since NO TM is a Halts TM, you cannot ask unbounded/large/GENERAL
> halting questions OF ANY tm.

Let's put George down as an HYPOTHESIS 0 supporter!

HYPOTHESIS 0
THE HALTING PROOF SHOWS THAT THE FUNCTION HALT() IS UNCOMPUTABLE

HYPOTHESIS 1
THE HALTING PROOF SHOWS THAT THE FUNCTION HALT() DOMAIN IS NOT OVER
ALL <FUNCTION, ARGUMENT> TUPLES

Does anyone support HYPOTHESIS 1?


Herc

[Peter Olcott]

On 6/10/2012 7:26 PM, cplxphil wrote:

It is a yes or no question whether the TM can solve it or not, and the
*only* reason that a TM can not solve it is that it is an incorrect yes
or no question.

The mathematical mapping is not that hard, I can not see why most people
are not getting it.

X = 7 + 5;
mathematically maps to:
Assign the value of the sum of seven plus five to the integer variable
named X.
The math representation and the English representation have identical
semantic meanings.

In the self reference form of the Halting Problem (more literally (but
too clumsy to say) the self-reference form of the reason why the Halting
Problem can not be solved), the Turing Machine is asked the question
"Does your input TM halt on its input?"

From the software engineering point of view this is its question. From
the software engineering perspective it is required to answer the
question of its design specification. From a mathematicians point of
view the design specification would be missing and instead one would
examine the set of all finite length strings and find that none meet the
intended goal.

[Peter Olcott]

On 6/11/2012 9:29 PM, cplxphil wrote:
> Argh...you say that my paraphrase is incorrect, but then don't try to
> supply examples of a better one!

The best one was the original one:
�Does Turing Machine M halt on input of Turing Machine H and Turing
Machine M?�

Where M is defined as
---------------------
M(String H, String input):
if H(input, H, input) loop
else halt

[Peter Olcott]

On 6/12/2012 3:46 PM, Patricia Shanahan wrote:
> On 6/12/2012 9:13 AM, Leif Roar Moldskred wrote:
>> In comp.theory Graham Cooper<graham...@gmail.com> wrote:
>>>
>>> If your Question is DOES THE ALGORITHM WORK ON ALL INPUT PAIRS?
>>>
>>> then what would you call that question considering there are cases it
>>> gets wrong?
>>
>> "Answered."
>>
>
> This seems like the obvious, and obviously correct, answer.
>
> Even a single input pair for which the algorithm gets a wrong answer or
> fails to terminate is sufficient to prove the answer is "No.".
>

H is asked the question:

"Does your input TM halt on its input?"

The *only* possible answers to the question posed to the TM are its own
two final states, all other answers of every kind are not within the set
of possible answers.

[Graham Cooper]

On Jun 13, 11:47 am, Peter Olcott <OCR4Screen> wrote:
> On 6/11/2012 9:29 PM, cplxphil wrote:
>
> > Argh...you say that my paraphrase is incorrect, but then don't try to
> > supply examples of a better one!
>
> The best one was the original one:

> “Does Turing Machine M halt on input of Turing Machine H and Turing
> Machine M?”

>
> Where M is defined as
> ---------------------
> M(String H, String input):
> if H(input, H, input) loop
> else halt
>

I don't get where the 3 parameter functions are coming from.

Every <PROGRAM, ARGUMENT> Pair has a property IT-HALTS or NOT(IT-
HALTS)

Let's examine the ANTI-DIAGONAL METHOD USED IN HALT PROOF

---INPUT 1 2 3 4 5 6 7 8 9 10 11 12...
TM
1
2
3
4
5
6
7
8
9
10
11
12
...

If HALT is some TM-n, then all the OUTPUT VALUES of HALT appear on
some row.


---INPUT 1 2 3 4 5 6 7 8 9 10 11 12...
TM
1
2
3
4
5
6
7
8 .......... 0 1 0 0 0 0 0 1 1 1 0 0 0 1 1 ....
9
10
11
12
...

EG.
TM-8(1) = 0

or HALT(1) = 0

i.e TM-1 has property NOT(IT-HALTS)

When WE Run
TM-8(8)

we are performing the computation equivalent to asking:

"Does your input TM halt on its input?"

------

To obtain a contradiction you can create secondary functions or split
the input into a tuple to input any parameter into the TM itself.

Herc

[George Greene]

On Jun 12, 9:43 pm, Peter Olcott <OCR4Screen> wrote:
> > 1>  A Turing machine that could solve the halting problem must map to
> > a yes or no question.

EVERY Turing Machine maps to a yes or no question.
On EVERY possible input, EVERY tm either halts or it doesn't.
You therefore have the option of treating EVERY invocation of EVERY tm
as asking a yes or no question.
If it halts then you can determine yes or no as a simple string
function of the string output. If it doesn't halt then you can just
arbitrarily DECIDE
that not halting MEANS any of 1) yes, 2) no, or 3) refusing to answer
at all (answer undefined).
The standard "theoretical" way of mapping this is to say that every TM
corresponds to a "language" and that those input-strings
for which the TM halts receive an answer of "yes" to the yes-or-no
question, "Is the input string IN the language corresponding to the
TM".
Input-strings for which the TM does NOT halt receive the answer of
"no" to THAT SAME question.

> It is a yes or no question whether the TM can solve it or not,

"Whether a tm can solve it or not" MEANS "there exists a TM that
solves it (or there doesn't)".
This is indeed a yes or no question and its answer is, NO, THERE DOES
NOT EXIST a TM that can solve this problem.

> and the *only* reason that a TM can not solve it is that it is an incorrect yes or no question.

THIS IS *BULLSHIT*. EVERY INSTANCE of this question is well-formed
AND HAS a yes or no answer,
so THERE IS NO POSSIBLE WAY that the question in general could be ill
formed. You are JUST LYING.
There is nothing wrong or inappropriate about this OR ANY question.
It is ALWAYS a well-formed question,
"Does there exist a TM such that [whatEVER]", if the whatever is well-
formed.

> The mathematical mapping is not that hard, I can not see why most people are not getting it.

YOU ARE THE ONE NOT GETTING IT.
WE GET IT. WE KNOW that there is no TM solving the halting problem
for the SAME reason that there
is no TM with the longest program and no largest number. You can
ALWAYS write a HARDER program!

>
> X = 7 + 5;
> mathematically maps to:
> Assign the value of the sum of seven plus five to the integer variable
> named X.

NO, DUMBASS, IT DOESN'T. With TMs, EVERYTHING IS A CONSTANT.
Assigning something to a variable is encoded as A CHANGE OF STATE.
Moreover, the TM version of this DOESN'T TREAT THE ANSWER AS A
VARIABLE IN ANY CASE!!!
The TM version of this treats the sum/answer AS THE OUTPUT! IT JUST
WRITES 12 ON THE TAPE!
NO X REQUIRED!!

[Graham Cooper]

On Jun 13, 1:47 pm, George Greene <gree...@email.unc.edu> wrote:
> "Does there exist a TM such that [whatEVER]", if the whatever is well-
> formed.
>
> > The mathematical mapping is not that hard, I can not see why most people  are not getting it.
>
> YOU ARE THE ONE NOT GETTING IT.
> WE GET IT.  WE KNOW that there is no TM solving the halting problem
> for the SAME reason that there
> is no TM with the longest program and no largest number.  You can
> ALWAYS write a HARDER program!

You mean:

INPUT(n) IF HALT(n,n) THEN LOOP

NO YOU CANNOT GEORGE!

*************************

WE SPECIFIED HALT() TO TAKE ANY <TM, ARGUMENT> PAIR
AND ***OUTPUT*** ON THE TAPE 1 FOR HALTS, 0 FOR HANGS.

*************************

YOU CHANGED PROTOCOL! YOU CHEATED!

HYPOTHESIS 0
THE HALTING PROOF SHOWS THAT THE FUNCTION HALT() IS UNCOMPUTABLE

HYPOTHESIS 1
THE HALTING PROOF SHOWS THAT THE FUNCTION HALT() DOMAIN IS NOT OVER
ALL <FUNCTION, ARGUMENT> TUPLES

You dodge the TOPIC George.

Is H1 true?

************

I SUGGEST: a SMALLER HALT PROBLEM be studied.

DOES A HALT(PROGRAM) FUNCTION EXIST THAT

GIVEN ANY GODEL NUMBER OF A PROGRAM
THAT HAS ZERO PARAMETERS

OUTPUTS 1 IFF PROGRAM TERMINATES
OUTPUTS 0 IFF PROGRAM HANGS

************

This will give you Ample scope to test ANY Function and Argument Pair,

since for every

TM-n(INPUT)

there is a

TM-q()

that computes the same result.

Herc

[George Greene]

On Jun 12, 9:57 pm, Peter Olcott <OCR4Screen> wrote:
> H is asked the question:
> "Does your input TM halt on its input?"

*NO*,*DUMBMASS*, H *IS*NOT* asked THAT question because H CANNOT be
asked THAT question, because H
IS NOT A *HALTS* TM! IN ORDER to be asked the question, "Does your
1st parameter halt on your 2nd?", you must FIRST BE
a HALTS tm.

This is NOT supposed to be HARD to understand!

Suppose I have an ADDITION tm. Suppose I have a TM that expects to
get 2 numbers as input strings and is guaranteed to write the string
meaning THE SUM of the two input numbers ON THE TAPE AS OUTPUT (and
then halt).
THIS TM CANNOT BE ASKED ANY questions OTHER than ADDITION questions!
FOR ANY string input you give it, it is going to break the string into
a 1st and 2nd number, and then write the string for the sum of those
two numbers on the tape! ALWAYS! Therefore, ADDITION questions are
THE ONLY KINDS of questions that this machine CAN be asked! You
canNOT ASK this machine questions about subtraction, division, or
halting, unless you first do some very fancy recoding.
BECAUSE it is in ADDITION tm, it CAN ONLY BE ASKED questions about
ADDITION PROBLEMS.

IN ORDER for H to be asked questions about halting, H would FIRST HAVE
TO *BE* a Halts TM. SINCE H ISN'T a Halts TM, NO inputs to H EVER
constitute asking H a question about halting! Unless, of course, they
are pre-restricted to some finite simplistic subdomain. In that case,
ALL FINITARY questions ARE ALWAYS EASY for TMs in general, so H
*could* be interpreted as being asked (and answering) a halting
question IF it were a question about the halting of a machine MUCH
SMALLER AND SIMPLER THAN H itself.
But H itself ISN'T smaller or simpler than H.

[Graham Cooper]

HALT(halt()) is asking the Question to Halt

"Does *your* TM halt on its input?"

This is Peter's argument or HYPOTHESIS.

You don't rebuke the Hypothesis, this is not a debate to score points.

If your problem with the argument in general is about size of H you
need to explain why.

certainly small algorithms can work on larger ones.

[Graham Cooper]

On Jun 13, 2:59 pm, Graham Cooper <grahamcoop...@gmail.com> wrote:
>
> ************
>
> I SUGGEST:  a SMALLER HALT PROBLEM be studied.
>
> DOES A HALT(PROGRAM) FUNCTION EXIST THAT
>
> GIVEN ANY GODEL NUMBER OF A PROGRAM
> THAT HAS ZERO PARAMETERS
>
> OUTPUTS 1 IFF PROGRAM TERMINATES
> OUTPUTS 0 IFF PROGRAM HANGS
>
> ************

It's becoming apparent there is no real counter-argument by the
UNCOMPUTABLE crowd.

You are all just resting on the assumption that nobody has programmed
a HALT() function yet and reverse engineering that observation into a
massively erroneous 100 y.o. proof!

WE KNOW WE DON'T HAVE *THE ACTUAL SOLUTION* YET!!!!


1 ALL TUPLES <TM, ARGUMENT> HAVE A PROPERTY IT-HALTS v NOT-IT-HALTS

2 SUPPOSE A HALT FUNCTION COMPUTES ALL [1]
YOU CAN'T GET TO STEP 2!

3 THE SCOPE OF THE HALT FUNCTION IS TO OUTPUT
1 OR 0, I.E. WRITE ON THE TAPE THE ANSWER THEN HALT

4 YOUR CONSTRUCTED FUNCTION

INPUT(n): IF HALT(n,n) THEN LOOP

IS COMPUTABLE IF HALT IS COMPUTABLE

*BUT IT BREAKS THE SCOPE DEFINED FOR HALT

YOU CAN'T *READ* THE TAPE OF THE OUTPUT OF ANOTHER TM


******THIS IS YOUR ERROR*****

INPUT(n): IF SUB_HALT(n,n) THEN LOOP

MAKING SUB_HALT A SUBPROCEDURE PUTS IT OUT OF IT'S ORIGINAL SCOPE.

YES YOU CAN DO IT!

BUT NO - IT'S NOT THE HALT FUNCTION ANY MORE.

LIKE:

FUNCTION TWO-TO-X(X)
RETURN EXP(2,X)


THIS IS THE TWO-TO-X FUNCTION, NOT EXPONENTIATION

SAME CODE - DIFFERENT FUNCTION


Herc

[Graham Cooper]

> INPUT(n): IF SUB_HALT(n,n) THEN LOOP
>
> MAKING SUB_HALT A SUBPROCEDURE PUTS IT OUT OF IT'S ORIGINAL SCOPE.
>
> YES YOU CAN DO IT!
>
> BUT NO - IT'S NOT THE HALT FUNCTION ANY MORE.
>
> LIKE:
>
> FUNCTION TWO-TO-X(X)
>    RETURN EXP(2,X)
>
> THIS IS THE TWO-TO-X FUNCTION, NOT EXPONENTIATION
>
> SAME CODE - DIFFERENT FUNCTION
>
> Herc

a better illustration..

FUNCTION X-SQUARED(X)
   RETURN EXP(X,2)

THIS IS THE X^2 FUNCTION, NOT EXPONENTIATION

SAME CODE - DIFFERENT FUNCTION

X-SQUARED will work fine regardless of extra conditions and rules of
negative exponents and what not.




****

DO FUNNY-LOOPS

INPUT(n): IF SUB_HALT(n,n) THEN LOOP

THIS IS USING SUB-HALT, NOT THE HALT FUNCTION

Herc

[George Greene]

On Jun 13, 7:32 pm, Graham Cooper <grahamcoop...@gmail.com> wrote:
> HALT(halt()) is asking the Question to Halt

Your notation ISN'T EVEN DEFINED. Since NO HALTS TM EXISTS,
writing "halt" and putting parentheses around it DOESN'T MEAN
anything.

> "Does *your* TM halt on its input?"

You can ask that question in English but the POINT is that you canNOT
ask that question OF a TM in the general case.

> This is Peter's argument or HYPOTHESIS.

NO, IT ISN'T, *DUMBASS*. It was OUR hypothesis. WE WERE THE ONES who
POSITED or hypothesized a TM H
that was ALLEGED to be a halt-decider, and then DERIVED A
CONTRADICTION FROM that allegation!\

> You don't rebuke the Hypothesis, this is not a debate to score points.

No, dumbas, you don't REBUKE the hypothesis, you reBUT and reFUTE the
hypothesis,
BY PROVING THAT IT IMPLIES A CONTRADICTION, WHICH WE DID.

Unfortunately, Peter Olcott IS A DUMBASS and so he does NOT UNDERSTAND
that this CONSTITUTES
a NON-existence proof for a halt-deciding TM (since H could have been
ANY tm, since H was an ARBITRARY
tm, this proof of H's failing to be a halt-deciding TM is also a proof
that EVERY tm fails to be a halt-deciding TM).

[Peter Olcott]

"George Greene" <gre...@email.unc.edu> wrote in message
news:a387b7af-5763-452d...@z19g2000vbe.googlegroups.com...

On Jun 12, 9:57 pm, Peter Olcott <OCR4Screen> wrote:
> H is asked the question:
> "Does your input TM halt on its input?"

*NO*,*DUMBMASS*, H *IS*NOT* asked THAT question because H CANNOT be
asked THAT question, because H
IS NOT A *HALTS* TM! IN ORDER to be asked the question, "Does your
1st parameter halt on your 2nd?", you must FIRST BE
a HALTS tm.

How is that not analogous to saying that it is impossible to ask a question
that someone does not know the answer to?

If one examines the set of finite length strings, one will find within this
set a Turing Machine that knows every natural language on the planet, and
knows every single detail of everything that is currently known about
anything, and has reasoning capability at least equal to the ability of each
of the best human experts in each field of inquiry.

You are saying that this machine can not even be asked the question:
"Does this TM halt on its input?"

[Graham Cooper]

On Jun 15, 9:26 pm, "Peter Olcott" <NoS...@OCR4Screen.com> wrote:
>
> You are saying that this machine can not even be asked the question:
> "Does this TM halt on its input?"

George seems unable to distinguish between the topic and the halting
proof, and takes every opportunity to reverse engineer his answer
backwards from "NO! NO! NO! You're not allowed to use the term HALT
in ANY ARGUMENT!"

George acknowledges you can *ASK* a TM "Does this TM halt?"

But when you explain the self reference to him...

"Does YOUR TM halt?"

he invokes the Result of the halting proof in order to argue why the
halting proof is correct!

You will never get anywhere with these die hard classic theorists who
" ..studied years and years .." all their bullshit!

10 IF HALT() GOTO 10

WHO ON EARTH WOULD BELIEVE THIS BULLSHIT??

IF I TOLD MY BOSS - SORRY WE CAN'T PROGRAM THE TEST HARNESS BECAUSE IF
IT WENT INTO AN INFINITE LOOP DECIDING IF IT HALTED OR NOT AND DOING
THE OPPOSITE IT WOULD BE UN-COMPUTABLE!

HE'S FIRE MY ASS AND HIRE A COMPETENT PROGRAMMER!

[Graham Cooper]

>
> IF I TOLD MY BOSS - SORRY WE CAN'T PROGRAM THE TEST HARNESS BECAUSE IF
> IT WENT INTO AN INFINITE LOOP DECIDING IF IT HALTED OR NOT AND DOING
> THE OPPOSITE IT WOULD BE UN-COMPUTABLE!
>
> HE'S FIRE MY ASS AND HIRE A COMPETENT PROGRAMMER!
>

HE'D FIRE MY ASS!

"Sorry Boss, can't program anything to check if the programs work,
imagine if we coded
10 IF HALT() THEN GOTO 10"

"Sorry Boss, can't program a Proof() Predicate to formally derive
anything, imagine if we coded
T|- G
G = !PROOF(G)

Herc
--
MATHEMATICS
E(Y) Y = {x|P(x)}
<->
PRVBLE( E(Y) Y = {x|P(x)} )

PRVBLE(T) <-> NOT(DERIVE(NOT(T)))
DERIVE(T) <-> E(a) E(b) DERIVE(a) ^ DERIVE(b) ^ (a^b)->T

[George Greene]

On Jun 15, 7:26 am, "Peter Olcott" <NoS...@OCR4Screen.com> wrote:
> How is that not analogous to saying that it is impossible to ask a question
> that someone does not know the answer to?

It's more analogous to asking someone a question IN A LANGUAGE THEY
DON'T UNDERSTAND.

>
> If one examines the set of finite length strings, one will find within this
> set a Turing Machine that knows every natural language on the planet,

NO, ONE WON'T, BECAUSE NATURAL LANGUAGES ARE MORE complex than TMs.

> and knows every single detail of everything that is currently known

That is just meaningless. Knowledge grows and there are levels.

> about anything,

That's just blatantly false. For one thing, YOU CAN'T EVEN *DEFINE*
"thing".

> and has reasoning capability at least equal to the ability of each
> of the best human experts in each field of inquiry.

There is nothing as simple as "reasoning ability equal to". The whole
thing is just more complicated than that.

> You are saying that this machine can not even be asked the question:
> "Does this TM halt on its input?"

I am saying that NO tm can be asked that IN THE GENERAL case.
If you are JUST talking about THE FINITE class of machines SMALLER
than some given size, THEN, YES, OF COURSE, THERE IS A *LARGER* tm
that
CAN be asked those questions. But that TM canNOT be asked BIGGER
questions.

It can't even be ASKED them.
It just DOESN'T UNDERSTAND them.
It does not know WHAT THEY MEAN.
Suppose, hypothetically, that you had a TM
that represented a 1000x1000 matrix that had a million cells.
Suppose the cells were indexed by the natnums 0..999 and each cell
contained the number
that was the sum of its row number and its column number.
In the (0,0) cell you would have 0 and in the (999,999) cell you would
have 1998.

You could write a TM to interpret its two inputs as a row and a column
for this matrix and to
return the sum (in the cell) from this matrix. You would think that
it was an addition TM.
It would behave exactly as the addition TM behaves as long as the
inputs were in range.
BUT WHAT IF THEY WERE OUT?? THEN WHAT??
What does this TM do when given (1111,1111) as an input string??

Well, I haven't said what it does, but the point is, whatEVER it does,
UNLESS it ALWAYS does the same thing
as the addition TM would do, it is NOT an addition TM, so putting that
input string to it DOES NOT CONSTITUTE ASKING IT
"What is 1111 + 1111?" Whatever answer it may give, it is not going
to give 2222. Now, you could say that it WAS asked
"What is 1111 + 1111?" and that it just gave the "wrong" answer. But
YOU, NOT IT, would be wrong to say THAT.
It CORRECTLY gives whatever answer it is PROGRAMMED to give. What the
QUESTION is depends NOT just on the input
string BUT ALSO ON HOW THE TM ITSELF IS PROGRAMMED.

If you say something to me, what I understand by it depends NOT ONLY
on the sounds coming out of your mouth but also on WHAT LANGUAGES I
SPEAK.

[Graham Cooper]

Fine, but you cannot bypass that the establishment of uncomputability
asks the question

CAN A CERTAIN TM DO SUCH-N-SUCH ON ALL TMs?

INFERS THE SELF-REFERENCING-QUESTION

CAN A CERTAIN TM DO SUCH-N-SUCH ON ITSELF?

***

We're not interested if you can use Q1 to dismiss Q2, we don't accept
Q1 either.

the halting proof is:
given a computable halt_program

you can construct a computable halt_function
and use that function in a 2nd function where the halt function's
value must be wrong

this is a very weak notion to define it as uncomputable
consider defining a distinction between

PROGRAM
and
FUNCTION that is used in subroutines


Herc
--

"Sorry Boss, can't program anything to check if the programs work,
imagine if we coded
10 IF HALT() THEN GOTO 10"

"Sorry Boss, can't program a Proof() Predicate to formally derive
anything, imagine if we coded
T|- G
G = !PROOF(G)

[Graham Cooper]

On Jun 16, 2:31 am, George Greene <gree...@email.unc.edu> wrote:

a TM can emulate bigger TMs.

As long as you can feed a representation of the bigger TM into the
input parameter.

the TOTAL SIZE of the computation is bigger than both of them, but a
small program can input a large parameter (and do more complex
calculations than it's small size alone can do with a small parameter)

If you consider the UTM^2 algorithm for taking increasing sizes of
UTMs, bigger and bigger emulators than you can get more and more
complicated permutations of N.

UTM1
1 2 3 4 5 6 .....

UTM2
10 4 5 6 3 8 ....

UTM3
...


but each permutation of N has a pattern!

the number 1 has to appear somewhere! ==UTM1(1, input)

and it appears further and further along the sequence..

99999999, 322323, 2323232, 33232, 383838, 123, 2323232, .... 2323, 1,
23, 34343434, ...

So PERMUTATIONS OF N are all in the shape of a TICK! DOWN THEN UP!

The remainder of the sequence is very close to
the remainder of the original sequence N!

Complexity grows and grows, then seems to plateau after a finite limit
of "all-there-is"

So I'm not so sure BIGGER MORE COMPLEX PROGRAMS can't be decoded by a
standard program.

HALT() might be exponential and useless in practice for commercial
software, but if you're going to argue that

10 IF HALT() GOTO 10

is the deciding factor of mathematics and computer science you should
buy a bridge in Nigeria!

Herc

[Patricia Shanahan]

On 6/15/2012 7:00 AM, Graham Cooper wrote:
...

> IF I TOLD MY BOSS - SORRY WE CAN'T PROGRAM THE TEST HARNESS BECAUSE IF
> IT WENT INTO AN INFINITE LOOP DECIDING IF IT HALTED OR NOT AND DOING
> THE OPPOSITE IT WOULD BE UN-COMPUTABLE!

And he would be right to do so, both for the attempt to build a general
halt decider into the test harness, and for failing to realize that
there are many useful tests that can be performed without depending on
the non-existent general halt decider.

The usual way of avoiding the problem in a practical test harness is to
include a timeout on the program under test.

In formal Turing machine terms, it is similar to deciding the set of TM
computations that terminate in no more than X steps, for some integer X.

Patricia

[Graham Cooper]

Sorry Boss, we can't program a Proof() Predicate to formally

derive anything, imagine if we coded
T|- G
G = !PROOF(G)

DERIVE(T) <-> E(a) E(b) DERIVE(a) ^ DERIVE(b) ^ (a^b)->T

Herc

--
http://tinyURL.com/BLUEPRINTS-TURING
http://tinyURL.com/BLUEPRINTS-CANTOR
http://tinyURL.com/BLUEPRINTS-GODEL
http://tinyURL.com/BLUEPRINTS-PROOF
http://tinyURL.com/BLUEPRINTS-LOGIC
http://tinyURL.com/BLUEPRINTS-MATHS
http://tinyURL.com/BLUEPRINTS-HALT
http://tinyURL.com/BLUEPRINTS-P-NP
http://tinyURL.com/BLUEPRINTS-GUT

[George Greene]

On Jun 15, 7:26 am, "Peter Olcott" <NoS...@OCR4Screen.com> wrote:

> If one examines the set of finite length strings

This is almost meaningless. To the extent that anyone understands
what it means, she understands that ONE DOES NOT (*ever*) do THIS
because
"the set of finite length strings" IS AN INFINITE SET. THEREORE, AT
NO TIME have the finite number of human beings EVER gotten around to
"examing" ALL of it,
NOR WILL WE EVER.

[Graham Cooper]

did he say "if one has EXAMINED all the set of finite length
strings" ??

If you rebuke all terminology, rebuke a halt program because a program
might check whether itself halts, rebuke any argument since "hard
problems will always be impossible" then you proved yourself into a
closed paradox and sealed the door!

HAIL THE EDUCATION SYSTEM that gave George a degree in LoGIc!

[Peter Olcott]

Mindless automaton stuck in refute mode.

[Graham Cooper]

How can an algorithm be "impossible" when even
the ORACLE VERSION of the Halt(p1) Program,
that randomly guesses the right halt() value,
can be twisted into a paradox?

If an Oracle-Halt() gave the right answer,
then LOOP IF O-HALTS()

How can you DESIGN a PROGRAM to check for INFINITE LOOPS,
then get a PROGRAM to CHECK ITSELF for an INFINITE LOOP
and do the opposite?

And call that - IMPOSSIBLE TO DETECT INFINITE LOOPS?

They don't even follow their own rules of TM computation!!!

1 Every <TM-n, i> Pair INFINITE LOOPS or NOT

2 ASSUME: HALT(n,i) WRITES ["INFLOOP" | "HALT"] for all Pairs in
[1]
on the infinite turing tape and then HALTS

****

They all BREAK the 2nd STEP!

WE only assumed a single TEST HARNESS HALT PROGRAM EXISTED,
not that it could be utilised as a general purpose function.

Enforcing that the HALT() TM HALTS after giving it's answer is part of
the specification of the algorithm.


Herc

[George Greene]

On Jun 15, 10:11 pm, Peter Olcott <OCR4Screen> wrote:

> Mindless automaton stuck in refute mode.

Mindless automaton not even addressing the actual issue, which was
about
the fact that the question being asked depends on the programming of
the interpreter,
not the string being interpreted.

[George Greene]

On Jun 15, 9:27 pm, Graham Cooper <grahamcoop...@gmail.com> wrote:
> If you rebuke all terminology, rebuke a halt program because a program
> might check whether itself halts, rebuke any argument

Is your native language English? You do not know the meaning of the
verb "rebuke".

[George Greene]

On Jun 15, 7:26 am, "Peter Olcott" <NoS...@OCR4Screen.com> wrote:

> If one examines the set of finite length strings, one will find within this
> set a Turing Machine that knows every natural language on the planet, and
> knows every single detail of everything that is currently known about
> anything,

This is utter bullshit. If one found such a TM, then ALSO IN THE SET
OF FINITE LENGTH STRINGS,
there would be A BIGGER tm that KNEW MORE than this. Except, oops,
the smaller one ALREADY KNEW "everything".
DAMN, you're stupid.
WE ALREADY KNOW some things that FOLLOW QUICKLY from OTHER things we
already know, DESPITE the fact
that nobody has gotten around to writing out the relevant (short)
proof yet. Every time you examine MORE of
"the set of finite length strings", you LEARN NEW THINGS. This
happens CONTINUALLY.
NOBODY EVER STOPS at "every single detail of everything that is
currently known". "Current" IS *ALWAYS* MOVING.
This is NOT relevant or important!
What is important is that what is known KEEPS GROWING ALL THE TIME,
WHEREFORE NOTHING *KNOWN* EVER IS something
that "knows every natural language on the planet and knows every
single detail of everything that is currently known about anything".

[Graham Cooper]

What kind of fact do you need >1,000,000 characters to represent that
999,999 won't do?

We're not talking about HISTORY and EVENTS and who won a baseball game
1/1/1999

I can formally derive any proof (using Oracle atm) using 3 formulas!

E(Y) Y = {x|P(x)} <-> PRVBLE( E(Y) Y = {x|P(x)} )
PRVBLE(T) <-> NOT(DERIVE(NOT(T)))

DERIVE(T) <-> E(a) E(b) DERIVE(a) ^ DERIVE(b) ^ (a^b)->T

You get a slightly different orientation of Mandelbrot images the
smaller and smaller square of the Complex Number Plane that you zoom
into, but it's a waste of time examining recurring variations of a
theme.


Herc

[Graham Cooper]

The Goal Shifting argument, endless ad nauseum ahead!

Everything is too hard <-> We don't know what we're saying!

Herc

[Graham Cooper]

Ahh sorry, haven't seen you actually refute anything as yet!

Herc

[Graham Cooper]

> > > If you rebuke all terminology, rebuke a halt program because a program
> > > might check whether itself halts, rebuke any argument
>
> > Is your native language English?  You do not know the meaning of the
> > verb "rebuke".
>

So tell us George, do you have ANY IDEA what we mean by

THE_SELF_REFERENCE aspect of the Halting Proof?

before we are detoured any further?

[Ben Bacarisse]

Graham Cooper <graham...@gmail.com> writes:
<snip>

> How can an algorithm be "impossible" when even
> the ORACLE VERSION of the Halt(p1) Program,
> that randomly guesses the right halt() value,
> can be twisted into a paradox?
>
> If an Oracle-Halt() gave the right answer,
> then LOOP IF O-HALTS()

An TM with a halting oracle isn't a TM, so you can't apply the "usual"
proof. You can't construct a TM that uses (in your terminology)
O-HALTS().

You can extend the model of computation, beyond TMs, to include oracle
machines. If TM_OH is the set of TMs with a halting oracle, you can
show that there is no M in TM+OH that decides halting for that set of
machines, but you can now posit an oracle for this new decidability
problem. You get an oracle for deciding halting of machines in TM_OH,
but, again, no contradiction can be derived because this new machine is
not in TM_OH.

There is an obvious "and so on".

> How can you DESIGN a PROGRAM to check for INFINITE LOOPS,
> then get a PROGRAM to CHECK ITSELF for an INFINITE LOOP
> and do the opposite?

Exactly -- you can't.

> And call that - IMPOSSIBLE TO DETECT INFINITE LOOPS?

There are only two choices: either the construction of the derived
machine is impossible, or the machine to decide halting is impossible.
Since the construction is trivial, what are you left with?

<snip>
--
Ben.

[Peter Olcott]

You are a mindless automaton stuck in refute mode!
If A TM had all of the knowledge in the world encoded within it, then
the question:
"Does this TM instance halt on its input instance?"
depends upon:
(a) This string: "Does this TM instance halt on its input instance?"
(b) The input TM instance.
(b) The input TM instance's input instance.

[Peter Olcott]

On 6/16/2012 3:00 AM, Graham Cooper wrote:
>>>> If you rebuke all terminology, rebuke a halt program because a program
>>>> might check whether itself halts, rebuke any argument
>>> Is your native language English? You do not know the meaning of the
>>> verb "rebuke".
> So tell us George, do you have ANY IDEA what we mean by
>
> THE_SELF_REFERENCE aspect of the Halting Proof?

I call it Pathological Self Reference because it derives an ill-formed
question.

An ill-formed question is defined as any question that lacks a correct
answer form the set of all possible answers.

[Peter Olcott]

On 6/16/2012 6:31 AM, Ben Bacarisse wrote:
> Graham Cooper<graham...@gmail.com> writes:
> <snip>
>> How can an algorithm be "impossible" when even
>> the ORACLE VERSION of the Halt(p1) Program,
>> that randomly guesses the right halt() value,
>> can be twisted into a paradox?
>>
>> If an Oracle-Halt() gave the right answer,
>> then LOOP IF O-HALTS()
> An TM with a halting oracle isn't a TM, so you can't apply the "usual"
> proof. You can't construct a TM that uses (in your terminology)
> O-HALTS().

That does not matter. The question behind the Pathological Self
Reference form of the Halting Problem would be unsolvable even for an
all-knowing mind because this question is ill-formed.

[LudovicoVan]

"Ben Bacarisse" <ben.u...@bsb.me.uk> wrote in message
news:0.73d1d062cab079c41ba4.2012...@bsb.me.uk...

> Graham Cooper <graham...@gmail.com> writes:
<snip>

>> And call that - IMPOSSIBLE TO DETECT INFINITE LOOPS?
>
> There are only two choices: either the construction of the derived
> machine is impossible, or the machine to decide halting is impossible.
> Since the construction is trivial, what are you left with?

But the objection there is not really that such definitions are impossible,
rather it is about which of these belong to the given collection of machines
and which don't and require an enlargement of the domain. IOW, which are
machines, which are meta-machines, which are meta-meta-machines, and so
n. -- I am still looking around for different proofs of the unsolvability
of the halting problem, first- and second-order, but surely a proof where we
posit a machine T that contradicts H to conclude that H cannot exist looks a
very "weak" argument.

-LV

[LudovicoVan]

"Peter Olcott" <OCR4Screen> wrote in message
news:eqidnbIl7qhw6kHS...@giganews.com...
<snip>

> The question behind the Pathological Self Reference form of the Halting
> Problem would be unsolvable even for an all-knowing mind because this
> question is ill-formed.

Sorry, maybe I have missed the critical posts, but which question is this?
Could you please state it?

I know the usual one: "Is there a TM that can tell the halting behavior of
any TM-input pair?", and the answer is (provably) no. Then one might
question the proof, but the question seems valid.

-LV

[Peter Olcott]

"Does the input TM instance halt on its input?"

[LudovicoVan]

"Peter Olcott" <OCR4Screen> wrote in message

news:i_SdnUZNm_rxAUHS...@giganews.com...

> "Does the input TM instance halt on its input?"

That would be a sub-question, where you are constraining the input to be the
given TM's code, so implicitly assuming that you have a coding for the TMs
(which is something not necessarily implied by the original, more general
question). Spelled out, this would be the question: "Is there a TM that
can tell the halting behavior of any TM-input pair, where input is equal to
the code of the given TM itself?" I still cannot see anything invalid, not
even with this (sub-)question: for instance, one could conceive a TM that
does negation of its input: when the input corresponds to the code of this
TM itself, nothing "invalid" happens. As another example, the putative
universal halt decider, even if assumed to be a TM, should have no problems
in telling its own halting behavior: in fact, by construction hypothesis, it
always halts.

That said, I still have to see a working and convincing proof (except maybe
for the ruling out of impredicativity in the second-order proof; my fault
for not having a final answer on this issue), but, as said, that would be an
objection to the proof, not to the question (not to the original one and,
most probably, not even to the sub-question).

-LV

[Peter Olcott]

On 6/16/2012 10:20 AM, LudovicoVan wrote:
> "Peter Olcott" <OCR4Screen> wrote in message
> news:i_SdnUZNm_rxAUHS...@giganews.com...
>> On 6/16/2012 8:14 AM, LudovicoVan wrote:
>>> "Peter Olcott" <OCR4Screen> wrote in message
>>> news:eqidnbIl7qhw6kHS...@giganews.com...
>>> <snip>
>>>
>>>> The question behind the Pathological Self Reference form of the
>>>> Halting Problem would be unsolvable even for an all-knowing mind
>>>> because this question is ill-formed.
>>>
>>> Sorry, maybe I have missed the critical posts, but which question is
>>> this? Could you please state it?
>>>
>>> I know the usual one: "Is there a TM that can tell the halting
>>> behavior of any TM-input pair?", and the answer is (provably) no.
>>> Then one might question the proof, but the question seems valid.
>>
>> "Does the input TM instance halt on its input?"
>
> That would be a sub-question,

It is the core question behind the reason why the Pathological
Self-Reference form of the Halting Problem can not be solved.

> where you are constraining the input to be the given TM's code, so
> implicitly assuming that you have a coding for the TMs (which is
> something not necessarily implied by the original, more general
> question).

When one takes into account AI knowledge representation, then this TM
could have encoded within it the sum total of everything known to date
about everything and anything, along with reasoning at least equal to
the best human in each field of inquiry. Taking this example to its
logical extreme, the question then becomes:
Could any all-knowing mind solve the Halting Problem?

[LudovicoVan]

"Peter Olcott" <OCR4Screen> wrote in message

news:JZ-dneL4K_TiMUHS...@giganews.com...

> On 6/16/2012 10:20 AM, LudovicoVan wrote:
>> "Peter Olcott" <OCR4Screen> wrote in message
>> news:i_SdnUZNm_rxAUHS...@giganews.com...
>>> On 6/16/2012 8:14 AM, LudovicoVan wrote:
>>>> "Peter Olcott" <OCR4Screen> wrote in message
>>>> news:eqidnbIl7qhw6kHS...@giganews.com...
>>>> <snip>
>>>>
>>>>> The question behind the Pathological Self Reference form of the
>>>>> Halting Problem would be unsolvable even for an all-knowing mind
>>>>> because this question is ill-formed.
>>>>
>>>> Sorry, maybe I have missed the critical posts, but which question is
>>>> this? Could you please state it?
>>>>
>>>> I know the usual one: "Is there a TM that can tell the halting behavior
>>>> of any TM-input pair?", and the answer is (provably) no. Then one
>>>> might question the proof, but the question seems valid.
>>>
>>> "Does the input TM instance halt on its input?"
>>
>> That would be a sub-question,
>
> It is the core question behind the reason why the Pathological
> Self-Reference form of the Halting Problem can not be solved.

But you now move to yet another different question.

>> where you are constraining the input to be the given TM's code, so
>> implicitly assuming that you have a coding for the TMs (which is
>> something not necessarily implied by the original, more general
>> question).
>
> When one takes into account AI knowledge representation, then this TM
> could have encoded within it the sum total of everything known to date
> about everything and anything, along with reasoning at least equal to the
> best human in each field of inquiry. Taking this example to its logical
> extreme, the question then becomes:
> Could any all-knowing mind solve the Halting Problem?

I do not see the "continuity" from the original question: never mind, in
this case, by definition, the answer would be "yes". Of course, it isn't
about a TM and not even about human minds. OTOH, I still cannot see how
the original question (the "halting problem") should be ill-formed.

-LV

[Peter Olcott]

On 6/16/2012 1:43 PM, LudovicoVan wrote:
> "Peter Olcott" <OCR4Screen> wrote in message
> news:JZ-dneL4K_TiMUHS...@giganews.com...
>> On 6/16/2012 10:20 AM, LudovicoVan wrote:
>>> "Peter Olcott" <OCR4Screen> wrote in message
>>> news:i_SdnUZNm_rxAUHS...@giganews.com...
>>>> On 6/16/2012 8:14 AM, LudovicoVan wrote:
>>>>> "Peter Olcott" <OCR4Screen> wrote in message
>>>>> news:eqidnbIl7qhw6kHS...@giganews.com...
>>>>> <snip>
>>>>>
>>>>>> The question behind the Pathological Self Reference form of the
>>>>>> Halting Problem would be unsolvable even for an all-knowing mind
>>>>>> because this question is ill-formed.
>>>>>
>>>>> Sorry, maybe I have missed the critical posts, but which question
>>>>> is this? Could you please state it?
>>>>>
>>>>> I know the usual one: "Is there a TM that can tell the halting
>>>>> behavior of any TM-input pair?", and the answer is (provably) no.
>>>>> Then one might question the proof, but the question seems valid.
>>>>
>>>> "Does the input TM instance halt on its input?"
>>>
>>> That would be a sub-question,
>>
>> It is the core question behind the reason why the Pathological
>> Self-Reference form of the Halting Problem can not be solved.
>
> But you now move to yet another different question.

No it has always been the same question for the several thousand times
that I have stated it.

>
>>> where you are constraining the input to be the given TM's code, so
>>> implicitly assuming that you have a coding for the TMs (which is
>>> something not necessarily implied by the original, more general
>>> question).
>>
>> When one takes into account AI knowledge representation, then this TM
>> could have encoded within it the sum total of everything known to
>> date about everything and anything, along with reasoning at least
>> equal to the best human in each field of inquiry. Taking this example
>> to its logical extreme, the question then becomes:
>> Could any all-knowing mind solve the Halting Problem?
>
> I do not see the "continuity" from the original question: never mind,
> in this case, by definition, the answer would be "yes". Of course, it
> isn't about a TM and not even about human minds. OTOH, I still
> cannot see how the original question (the "halting problem") should be
> ill-formed.
>
> -LV
>

If no element of the set of Turing Machines can solve the self reference
form of the Halting Problem, then the element of this set that would
derive a mind that knows everything currently known would also not be
able to solve the HP. Since this element would necessarily also know the
syntax and Semantics of every human language that ever existed, it could
be asked this question in English: "Will this TM instance halt on this
input instance?"

If this TM can not answer this question then this question must
necessarily be ill-formed.

[LudovicoVan]

"Peter Olcott" <OCR4Screen> wrote in message

news:taWdnZf2gKbJREHS...@giganews.com...
<snip>

> If this TM can not answer this question then this question must
> necessarily be ill-formed.

It cannot be a TM, while the question can be and has been answered. I
cannot follow your line of reasoning, in fact I cannot see any line of
reasoning.

-LV

[Peter Olcott]

Can a TM compute anything computable?
Can anything computable include knowledge?
Can knowledge include knowledge of the syntax and semantics of human
languages?

[Graham Cooper]

On Jun 16, 9:31 pm, Ben Bacarisse <ben.use...@bsb.me.uk> wrote:

You don't even follow your own rules of TM construction.

1 Every <TM-n, i> Pair INFINITE LOOPS or NOT

2 ASSUME: HALT(n,i) WRITES ["INFLOOP" | "HALT"] for all [1]

on the infinite turing tape and then HALTS

You can construct a MONA-LISA Painting algorithm
using the code somewhere X++

Proving a fact about the un-paintability of the Mona Lisa by an
algorithm says nothing about the correctness of the sub-code X++

It's WHAT YOU DO with the HALT PROGRAM that is wrong!

Herc

[Graham Cooper]

On Jun 17, 1:20 am, "LudovicoVan" <ju...@diegidio.name> wrote:
> "Peter Olcott" <OCR4Screen> wrote in message
>
>
> > On 6/16/2012 8:14 AM, LudovicoVan wrote:
> >> "Peter Olcott" <OCR4Screen> wrote in message
> >>news:eqidnbIl7qhw6kHS...@giganews.com...
> >> <snip>
>
> >>> The question behind the Pathological Self Reference form of the Halting
> >>> Problem would be unsolvable even for an all-knowing mind because this
> >>> question is ill-formed.
>
> >> Sorry, maybe I have missed the critical posts, but which question is
> >> this? Could you please state it?
>
> >> I know the usual one: "Is there a TM that can tell the halting behavior
> >> of any TM-input pair?", and the answer is (provably) no.  Then one might
> >> question the proof, but the question seems valid.
>
> > "Does the input TM instance halt on its input?"
>
> That would be a sub-question, where you are constraining the input to be the
> given TM's code, so implicitly assuming that you have a coding for the TMs
> (which is something not necessarily implied by the original, more general
> question).  Spelled out, this would be the question:  "Is there a TM that
> can tell the halting behavior of any TM-input pair, where input is equal to
> the code of the given TM itself?"  I still cannot see anything invalid, not

It's a self reference.

It's like saying... you can never avoid infinite loops when
programming
because you could program an infinite loop (on the condition that it
detected itself didn't infinite loop)

yeh so? DONT PROGRAM THAT!

Herc

[LudovicoVan]

"Peter Olcott" <OCR4Screen> wrote in message

news:jrednTblnqYLe0HS...@giganews.com...

> On 6/16/2012 2:15 PM, LudovicoVan wrote:
>> "Peter Olcott" <OCR4Screen> wrote in message
>> news:taWdnZf2gKbJREHS...@giganews.com...
>> <snip>
>>
>>> If this TM can not answer this question then this question must
>>> necessarily be ill-formed.
>>
>> It cannot be a TM, while the question can be and has been answered. I
>> cannot follow your line of reasoning, in fact I cannot see any line of
>> reasoning.
>

> Can a TM compute anything computable?

Yes, an Universal Turing Machine can do so. (For all we know, "anything
computable" does not include the halting problem.)

> Can anything computable include knowledge?

No: on the contrary, you could say that knowledge includes things computable
(so that these are part of what can be known, they do not include or exhaust
it).

> Can knowledge include knowledge of the syntax and semantics of human
> languages?

Of course.

Strictly speaking, a TM has no "knowledge", except maybe for the knowledge
underlying the algorithm it implements, which ultimately remains *our*
knowledge.

-LV

[Graham Cooper]

So your brain is doing something EXTRA than symbol manipulation?

SCORES(BASEBALL, YANKEES, 22, RED-SOX, 14, BLUE-STADIUM, 4/1/2012)

is not a FACT or KNOWLEDGE?



Herc

[LudovicoVan]

"Graham Cooper" <graham...@gmail.com> wrote in message
news:32a505c1-413f-4e40...@s6g2000pbi.googlegroups.com...

> On Jun 17, 1:20 am, "LudovicoVan" <ju...@diegidio.name> wrote:

<snip>

>> I still cannot see anything invalid, not

You have snipped my examples.

> It's a self reference.

So what??

> It's like saying... you can never avoid infinite loops when
> programming

No, it's not. (And you can always avoid infinite loops when programming.)

-LV

[LudovicoVan]

"Graham Cooper" <graham...@gmail.com> wrote in message

news:9af0e89d-a755-42ef...@po9g2000pbb.googlegroups.com...

> So your brain is doing something EXTRA than symbol manipulation?

Maybe so, but the relevance to TMs and our discussion is ZERO.

> SCORES(BASEBALL, YANKEES, 22, RED-SOX, 14, BLUE-STADIUM, 4/1/2012)
>
> is not a FACT or KNOWLEDGE?

It is *part of* knowledge. Reread my post after switching your calculators
on.

-LV

[Graham Cooper]

On Jun 17, 8:40 am, "LudovicoVan" <ju...@diegidio.name> wrote:
> "Graham Cooper" <grahamcoop...@gmail.com> wrote in message

this bit?

> Can anything computable include knowledge?

No:

a TM has no "knowledge"

So Propositions and Predicates(),
sentences and formula that can be TRUE or FALSE
are disjoint to "knowledge" ?

Herc

[Graham Cooper]

On Jun 17, 8:37 am, "LudovicoVan" <ju...@diegidio.name> wrote:
> "Graham Cooper" <grahamcoop...@gmail.com> wrote in message
>
>

> <snip>
>
> >> I still cannot see anything invalid, not
>
> You have snipped my examples.
>
> > It's a self reference.
>
> So what??

how could I know? you snipped the sentence under discussion.

>
> > It's like saying...  you can never avoid infinite loops when
> > programming
>
> No, it's not.  (And you can always avoid infinite loops when programming.)
>
> -LV

Not systematically and still program any computable function.

That *IS* the Halting Proof!

--=That no function can test for infinite loops=--

Obviously basing the notion of *UNCOMPUTABLE*
on a proof about INFINITE-LOOPS would be seen as nonsense, so you get
the neatened up HALT() version.

Herc

[LudovicoVan]

"Graham Cooper" <graham...@gmail.com> wrote in message

news:ae59ea02-4125-4a6d...@l10g2000pbi.googlegroups.com...

> On Jun 17, 8:37 am, "LudovicoVan" <ju...@diegidio.name> wrote:
>> "Graham Cooper" <grahamcoop...@gmail.com> wrote in message
<snip>

>> > It's like saying... you can never avoid infinite loops when
>> > programming
>>
>> No, it's not. (And you can always avoid infinite loops when
>> programming.)
>

> Not systematically and still program any computable function.

Yes, systematically: not *generally*. Then I do not even know what you mean
by "program[ming] any computable function".

> That *IS* the Halting Proof!
>
> --=That no function can test for infinite loops=--

That is *not* the halting problem, which is to have a function that decides
halting *in general* (i.e. for any input).

> Obviously basing the notion of *UNCOMPUTABLE*
> on a proof about INFINITE-LOOPS would be seen as nonsense, so you get
> the neatened up HALT() version.

But this is wrong too when one looks nearer: you are assuming that any
machine that does not halt on some input does so in a periodic manner
("looping"), which is not necessarily the case.

-LV