Disproof of the Halting Problem's Conclusion
Peter Olcott
link:
http://home.att.net/~olcott/halts.html
The goal of this proof is to refute the Halting Problem's conclusion:
(paraphrase)
{It is impossible to construct a program that can determine if every program
halts.}
This informal proof depends upon the terminology of this link
http://www.netaxs.com/people/nerp/automata/halting2.html
to be understood.
This version of the Halting Problem is supposed to be analogous to every
other version, thus valid refutations of this version should equally apply
(with adaptation) to all other versions.
Process:
A running program in memory.
Static Program:
ASCII text that represents the source code of the program that can be edited
and compiled.
Assumptions:
(1) No process has any access to read the screen data.
(2) The WillHalt() process is located in protected memory, and any access to
this memory by other processes causes a memory protection fault error.
Body Of Proof
The basis of the original proof is a mechanism comparable to the
LoopIfHalts() function. If this basis could be disabled, then the original
proof would lose its basis, and fail.
The LoopIfHalts() function depends upon access to the return value of the
WillHalt() function. If every possible access to this return is completely
denied to every other program, then LoopIfHalts() can not possibly effect
the WillHalt() function. LoopIfHalts() would be unable to "loop if halts".
Simple Method
A simple way to eliminate access to the return value of WillHalt() is to
only put this return value on the screen, (and nowhere else) and not allow
any process read access to the screen data. This would of course also
require that the WillHalt() function not return a value to its caller.
Possible Bases For Refutation
It seems that the only possible way to refute this proof would have to take
the form of preventing my unmodified version of WillHalt() from working
correctly. Any changes made to the WillHalt() function will probably prove
fruitless for the following reasons:
Halting can be determined by my original unmodified version of Willhalt()
for every program, including those based on WillHalt(). The LoopIfHalts()
function is now bound to fail because WillHalt() does not return the boolean
value that it requires. Although changes can be make to WillHalt() such that
it can no longer determine if a program (including itself) will halt, my
original unmodified version would be able to correctly make this
determination for these programs.
G. Frege
>
> Assumptions:
> (1) No process has any access to read the screen data.
>
> (2) The WillHalt() process is located in protected memory, and any access to
> this memory by other processes causes a memory protection fault error.
>
We DON'T need access to a (the) screen nor to the memory used by
WillHalt().
All we need for the proof is the _assumption_ that there might be a
function which is able to determine correctly for every program P and
input I if P halts on input I or not.
Now you claim that WillHalt() i s able to perform that. But that
assumption leads directly to a contradiction.
Peter Olcott
> function which is able to determine correctly for every program P and
> input I if P halts on input I or not.
>
> Now you claim that WillHalt() i s able to perform that. But that
> assumption leads directly to a contradiction.
>
everything that I have said.
http://home.att.net/~olcott/halts.html
Read it very carefully so you are sure that you know
exactly what I am saying. Especially read the Bases
for Refutation section. This section was formed
specifically to address your "refutation".
Martin Shobe
wrote:
>> All we need for the proof is the _assumption_ that there might be a
I've read it, and your bases for refutation doesn't refute the
original proof. There are only two ways to refute a proof. You can
find a mistake in the proof, or you can disagree with an assumption.
(There is kind-of a third way, and that is to prove the opposite.
However, this just means that at least one of the first two conditions
holds.)
Since that page doesn't disagree with any assumptions, doesn't point
out any mistakes in the proof, and doesn't prove the opposite, I can
only conclude that no refutation of the proof has been made.
Martin
Tiefling
mathematical recursion theory, it's the foundation for degrees of
unsolvability, oracle constructions and so on. In logic it appears in
various flavors across mathematics, computer science and philosophy.
This problem (and it's proof) has been studied and expanded upon for years
by logicians in various fields, so it's highly improbable that something is
amiss or unrealized.
Many people has offered their input as to why they feel your argument is
flawed, ill posed, etc, and I can't say more than they already have.
So I will offer to float a few names to you: Robert Soare (Univ. of
Chicago), Ted Slaman (Berkeley), Steffen Lempp (Univ. of Wisconsion -
Madison).
These are all, superstar mathematical logicians who specialize in recursion
theory, ask them and let us know what they say.
Tiefling
Peter Olcott
> original proof. There are only two ways to refute a proof. You can
> find a mistake in the proof, or you can disagree with an assumption.
> (There is kind-of a third way, and that is to prove the opposite.
> However, this just means that at least one of the first two conditions
> holds.)
>
> Since that page doesn't disagree with any assumptions, doesn't point
> out any mistakes in the proof, and doesn't prove the opposite, I can
> only conclude that no refutation of the proof has been made.
>
> Martin
Even if your statement is correct, it is insufficient.
There must be much more details. Mostly you have
only posted unsupported claims. Try and support
these claims.
To say that my proof is incorrect because it is not framed
within the context of a Turing Machine does not form a valid
refutation of my claim. If you need to have this explained,
say so, and I will change my webpage to explain this.
Peter Olcott
"Tiefling" <tiefli...@hotmail.com> wrote in message
news:nS1Jc.10250$CS6....@newssvr25.news.prodigy.com...
> As you know, the halting problem around for some time. In classical
> mathematical recursion theory, it's the foundation for degrees of
> unsolvability, oracle constructions and so on. In logic it appears in
> various flavors across mathematics, computer science and philosophy.
>
> This problem (and it's proof) has been studied and expanded upon for years
> by logicians in various fields, so it's highly improbable that something
is
> amiss or unrealized.
I know, and I agree. It is even more unlikely that I would derive a correct
refutation in my spare time, just jabbering on Usenet. It is especially
unbelievable within the context of some of my prior postings weak bases.
One thing that I do know, is that unbelievable does not equate to untrue,
and this single error seems to have the greatest negative impact on mankind.
The only reason that I accept that my proof might be valid is that I can't
find any errors in it, nor can I find any place where errors could exist.
> Many people has offered their input as to why they feel your argument is
> flawed, ill posed, etc, and I can't say more than they already have.
Yet none of these were actual and factual refutations. Each of these
had serious flaws. Some of these flaws were too subtle for their
author's to see, even when pointed out.
> So I will offer to float a few names to you: Robert Soare (Univ. of
> Chicago), Ted Slaman (Berkeley), Steffen Lempp (Univ. of Wisconsion -
> Madison).
>
> These are all, superstar mathematical logicians who specialize in
recursion
> theory, ask them and let us know what they say.
I will refer back to these names at a later date, if necessary.
I am still waiting to see either a valid refutation or a consensus
of confirmation.
> Tiefling
>
>
George Greene
: The goal of this proof is to refute the Halting Problem's conclusion:
: (paraphrase)
: {It is impossible to construct a program that can determine if every program
: halts.}
PARAphrasing IS NOT acceptable!
That "It is impossible to construct a program that can determine if every program
: halts" IS NOT the halting problem's conclusion!
The Halting Problem is about A TURING MACHINE (NOT a program) that
decides whether every TURING MACHINE (on every input) does or doesn't halt!
: This informal proof depends upon the terminology of this link
: http://www.netaxs.com/people/nerp/automata/halting2.html
: to be understood.
You personally do not understand that page, so that is just irrelevant.
: This version of the Halting Problem is supposed to be analogous to every
: other version,
It's not analogous to any version.
: thus valid refutations of this version should equally apply
: (with adaptation) to all other versions.
:
: Process:
: A running program in memory.
Define running.
Define progrsam.
: Static Program:
: ASCII text that represents the source code of the program that can be edited
: and compiled.
Define edited.
Define compiled.
: Assumptions:
: (1) No process has any access to read the screen data.
Define read.
Define screen.
: (2) The WillHalt() process is located in protected memory, and any access to
: this memory by other processes causes a memory protection fault error.
Define protected.
: Body Of Proof
Oh, shut up.
All WE had to define was "Turing Machine" and "problem".
George Greene
: To say that my proof is incorrect because it is not framed
: within the context of a Turing Machine does not form a valid
: refutation of my claim.
IT DOES SO, TOO, DUMBASS.
"The Halting Problem" IS ABOUT Turing Machines.
It is NOT about "processes" with "memory" that can
"read screens".
--
--- The history of our nation has demonstrated that separate is seldom, if ever, equal.
--- (Feb.3,2004) Supreme Judicial Court of Massachusetts (4-3), adv.Sen.#2175
George Greene
: So I will offer to float a few names to you: Robert Soare (Univ. of
: Chicago), Ted Slaman (Berkeley), Steffen Lempp (Univ. of Wisconsion -
: Madison).
None of that is relevant.
What IS relevant is his refusal to adopt the relevant
VOCABULARY.
He thinks he already KNOWS what a Program is, what a Process is,
what Memory is, etc. etc. He knows none of these things. IF
he understood them then he would have a better chance of understanding
why they are NOT relevant to the halting problem.
Will Twentyman
> Most recently updated version of this informal proof will be posted on this
> link:
> http://home.att.net/~olcott/halts.html
>
> The goal of this proof is to refute the Halting Problem's conclusion:
> (paraphrase)
> {It is impossible to construct a program that can determine if every program
> halts.}
>
> This informal proof depends upon the terminology of this link
> http://www.netaxs.com/people/nerp/automata/halting2.html
> to be understood.
>
> This version of the Halting Problem is supposed to be analogous to every
> other version, thus valid refutations of this version should equally apply
> (with adaptation) to all other versions.
>
> Process:
> A running program in memory.
>
> Static Program:
> ASCII text that represents the source code of the program that can be edited
> and compiled.
>
> Assumptions:
> (1) No process has any access to read the screen data.
First problem. Turing machines do not have a screen, so this assumption
is meaningless.
> (2) The WillHalt() process is located in protected memory, and any access to
> this memory by other processes causes a memory protection fault error.
Second problem. What's to stop a person from taking the code for
WillHalt() and doing a copy/paste into some other function so that the
accessibility/inaccessibility of WillHalt()'s memory is irrelevant?
> Body Of Proof
> The basis of the original proof is a mechanism comparable to the
> LoopIfHalts() function. If this basis could be disabled, then the original
> proof would lose its basis, and fail.
This is simply not true. You are saying you can modify a working proof
into a broken proof. That does not make the working proof incorrect.
What you are saying is analogous to the following:
SharpShooter: "If I take this rifle with a properly adjusted sight, I
can shoot a bullseye at 20 feet on the first shot."
Peter: "Not if I screw up the sight!"
Taking the sight out of adjustment and watching SharpShooter miss does
not make SharpShooter wrong.
> The LoopIfHalts() function depends upon access to the return value of the
> WillHalt() function. If every possible access to this return is completely
> denied to every other program, then LoopIfHalts() can not possibly effect
> the WillHalt() function. LoopIfHalts() would be unable to "loop if halts".
>
> Simple Method
> A simple way to eliminate access to the return value of WillHalt() is to
> only put this return value on the screen, (and nowhere else) and not allow
> any process read access to the screen data. This would of course also
> require that the WillHalt() function not return a value to its caller.
So what you are saying is you want to *change* WillHalt() so that
instead of having a return value, it has no return value. In C, that
would be equivalent to changing from:
int WillHalt(a,b)
{
[do stuff]
return result;
}
to:
void WillHalt(a,b)
{
[do stuff]
printf("%d",result);
}
They are NOT the same function any more. They are different functions
with the same name. They do similar, but different things.
>
> Possible Bases For Refutation
> It seems that the only possible way to refute this proof would have to take
> the form of preventing my unmodified version of WillHalt() from working
> correctly. Any changes made to the WillHalt() function will probably prove
> fruitless for the following reasons:
>
> Halting can be determined by my original unmodified version of Willhalt()
> for every program, including those based on WillHalt(). The LoopIfHalts()
> function is now bound to fail because WillHalt() does not return the boolean
> value that it requires. Although changes can be make to WillHalt() such that
> it can no longer determine if a program (including itself) will halt, my
> original unmodified version would be able to correctly make this
> determination for these programs.
All you have done is shown that your modification makes the method of
proof outlined invalid. So what? The method of proof did not have your
modification and is still valid. You have only shown that if you make
modifications to the premises of a valid argument, the modified argument
may not be a valid argument.
Secondly, I can modify *your* argument by doing a copy/paste of the
WillHalt() code, then changing the return statement to an assignment
statement. This will get us back to the same problem.
--
Will Twentyman
email: wtwentyman at copper dot net
George Greene
[ a decent engagement of P.O.'s misguided fantasies [
for which we are all grateful. That approach is more likely
to work than mine and some others. We are rooting for you.
Personally I think you should get some kind of teaching award
if it works.
Peter Olcott
"G. Frege" <no_...@aol.com> wrote in message news:5c29f05de08762rgd...@4ax.com...
I want to make an official record of this before anyone else
comes to this conclusion. Apparently the original proof did
not show that creating a WillHalt() function that can always
determine if any other program will halt, is impossible. All that
the original proof has shown is that there is one way that can
not possibly work.
Basic Structure of the Original Proof:
Y makes X Impossible.
Basic Structure of my refutation:
Z makes Y impossible.
Peter Olcott
"George Greene" <gre...@greeneg-cs.cs.unc.edu> wrote in message news:xespt6y...@greeneg-cs.cs.unc.edu...
> "Peter Olcott" <olc...@worldnet.att.net> writes:
> : To say that my proof is incorrect because it is not framed
> : within the context of a Turing Machine does not form a valid
> : refutation of my claim.
>
> IT DOES SO, TOO, DUMBASS.
I know you are, but what am I?
(But only for your unprofessional rude behavior,)
> "The Halting Problem" IS ABOUT Turing Machines.
> It is NOT about "processes" with "memory" that can
> "read screens".
Try this more general definition from the National Institute of Standards and Technology. This will now be my official definition.
http://www.nist.gov/dads/HTML/haltingProblem.html
Chris Menzel
> I want to make an official record of this before anyone else comes to
> this conclusion. Apparently the original proof did not show that
> creating a WillHalt() function that can always determine if any other
> program will halt, is impossible. All that the original proof has
> shown is that there is one way that can not possibly work.
Goodness me; you are so terribly confused.
Peter Olcott
"George Greene" <gre...@greeneg-cs.cs.unc.edu> wrote in message news:xesu0wa...@greeneg-cs.cs.unc.edu...
> "Peter Olcott" <olc...@att.net> writes:
> : The goal of this proof is to refute the Halting Problem's conclusion:
> : (paraphrase)
> : {It is impossible to construct a program that can determine if every program
> : halts.}
>
> PARAphrasing IS NOT acceptable!
> That "It is impossible to construct a program that can determine if every program
> : halts" IS NOT the halting problem's conclusion!
> The Halting Problem is about A TURING MACHINE (NOT a program) that
> decides whether every TURING MACHINE (on every input) does or doesn't halt!
That's right I am sure that you have just proved that the
National Institutes of Standards and Technology is totally
off-base. After all everyone (but me) already knows that
George Greene is the ultimate authority on these matters.
http://www.nist.gov/dads/HTML/haltingProblem.html
Peter Olcott
"Chris Menzel" <cme...@remove-this.tamu.edu> wrote in message news:slrncfbj9n....@philebus.tamu.edu...
Find any error in what I have said.
All that you have done is make empty
baseless statements.
G. Frege
> >
> > That "It is impossible to construct a program that can determine if
> > every program halts [on some input]" IS NOT the halting problem's
> > conclusion!
> >
Well... On the other hand, can't we just claim that NO (von Neumann)
computer (i.e. program running on this computer) c a n compute what
a TM c a n't compute?
F.
Peter Olcott
"Chris Menzel" <cme...@remove-this.tamu.edu> wrote in message
news:slrncfbj9n....@philebus.tamu.edu...
has yet to have found a single actual error in any
of my last two threads?
Maybe it is not I who am confused. Maybe there
are several people that think making baseless assertions
means something, rather than nothing. If you can find
an error in either of my last two threads, PUT UP OR SHUT UP!
G. Frege
<olc...@worldnet.att.net> wrote:
> >
> > Goodness me; you are so terribly confused.
> >
> If it I who am confused then why is it that no one
> has yet to have found a single actual error in any
> of my last two threads?
>
Huh?!
You are r e a l l y terribly confused. (Or either a liar or a troll.)
>
> Maybe it is not I who am confused.
>
Maybe the earth is flat. Maybe the moon is made of green cheese.
F.
Kenneth Doyle
news:vZjJc.254624$Gx4....@bgtnsc04-news.ops.worldnet.att.net
:
> Try this more general definition from the National
> Institute of Standards and Technology. This will now be my
> official definition.
> http://www.nist.gov/dads/HTML/haltingProblem.html
>
Oh goody! Can we look forward to a week of you "exploring" the
meaning of "heuristic"?
--
CodeCutter - good, fast and cheap; pick two.
Peter Olcott
Maybe you never bothered to really read what I said.
Peter Olcott
"Kenneth Doyle" <nob...@notmail.com> wrote in message
news:Xns95278E9685B34...@61.9.191.5...
> "Peter Olcott" <olc...@att.net> wrote in
> news:vZjJc.254624$Gx4....@bgtnsc04-news.ops.worldnet.att.net
> :
>
> > Try this more general definition from the National
> > Institute of Standards and Technology. This will now be my
> > official definition.
> > http://www.nist.gov/dads/HTML/haltingProblem.html
> >
>
> Oh goody! Can we look forward to a week of you "exploring" the
> meaning of "heuristic"?
Not at all the only thing that I am referring to on this page is
this definition of the Halting Problem:
Definition: No program can ever be written to determine whether any
arbitrary program will halt.
G. Frege
<olc...@worldnet.att.net> wrote:
> > > >
> > > > Goodness me; you are so terribly confused.
> > > >
> > > If it I who am confused then why is it that no one
> > > has yet to have found a single actual error in any
> > > of my last two threads?
> > >
> > Huh?!
> >
> > You are r e a l l y terribly confused. (Or either a liar or a troll.)
> >
> > >
> > > Maybe it is not I who am confused.
> > >
> > Maybe the earth is flat. Maybe the moon is made of green cheese.
> >
> Maybe you never bothered to really read what I said.
>
Again: You are r e a l l y terribly confused.
READ WHAT? This silly little page full of nonsensical claims, but
lacking any substantial contents?
Chris Menzel
But see, that's the sad thing, Peter. People have put up and put up.
Your errors have been corrected and the flaws in your arguments have
been picked apart for you in excruciating detail again and again. So
while I could try to explain to you why your assertion above -- that the
original proof of the unsolvability of the Halting Problem simply yields
the completely uninteresting result that a particular *way* of trying to
code the Halt function fails -- is grossly mistaken; I could try to find
yet another way to explain the basics of computability to you in a way
that would enable you to see why you are wrong. But I and others have
already tried to do that, many times, and in many ways, but you seem
strangely unteachable. I sincerely hope the light comes on for you
someday.
Chris Menzel
Will Twentyman
It would be nice if they mentioned the restriction that the programming
language needs to be Turing-Complete for the problem to apply.
Will Twentyman
Stated another way: if Y is true, X is false. But, if Z is true, Y is
false.
Problem1, you have not shown that Z is tautologically true.
Problem2, Z true does not imply X is true.
Will Twentyman
The halting Problem is generally phrased in terms of either Turing
Machines or Turing-Complete languages. Unless you have in mind some
language that is *stronger* than Turing-Complete (and I don't believe
such a language exists in use), then talking about programs or Turing
Machines is interchangeable.
Also, NIST is concerned with practical considerations, so will be
phrased in a programming rather than mathematical frame of reference.
Perhaps the discussion at http://en.wikipedia.org/wiki/Halting_problem
and http://en.wikipedia.org/wiki/Algorithm will be more helpful. You
could also see http://mathworld.wolfram.com/HaltingProblem.html for a
definition.
Peter Olcott
> Your errors have been corrected and the flaws in your arguments have
> been picked apart for you in excruciating detail again and again. So
> while I could try to explain to you why your assertion above -- that the
> original proof of the unsolvability of the Halting Problem simply yields
> the completely uninteresting result that a particular *way* of trying to
> code the Halt function fails -- is grossly mistaken; I could try to find
> yet another way to explain the basics of computability to you in a way
> that would enable you to see why you are wrong. But I and others have
> already tried to do that, many times, and in many ways, but you seem
> strangely unteachable. I sincerely hope the light comes on for you
> someday.
>
> Chris Menzel
>
a refutation that again fails to find any errors in what
I have said.
I have claimed that is it possible to make access the
result of my program impossible to other programs.
G. Frege has created a line-of-reasoning that looks like
it addresses this point. No one else has even gotten
in the right ballpark, arguing all kinds of extraneous
issues. The primary basis for at least half of what has
been posing as a refutation has been nothing more
that I really think that you are worg, in other words
baseless.
Peter Olcott
> language needs to be Turing-Complete for the problem to apply.
>
> --
> Will Twentyman
> email: wtwentyman at copper dot net
If one program could correctly determine if every other program
halts, I am sure that your specific type of program would be
included in the universal set of all programs, don't you think?
Peter Olcott
> > Y makes X Impossible.
> >
> > Basic Structure of my refutation:
> > Z makes Y impossible.
>
> Stated another way: if Y is true, X is false. But, if Z is true, Y is
> false.
>
> Problem1, you have not shown that Z is tautologically true.
> Problem2, Z true does not imply X is true.
> --
> Will Twentyman
> email: wtwentyman at copper dot net
Great, you are two for two on this one.
Here is my counter
If Z is true then the proof that X is impossible is false.
I am not shooting for provein that X is true.
Z entails not Y has been shown.
No one has yet been able to show that Z is not true.
I don't think that it will be very long before either
someone finds a way to disable Z, or Z is known to
be tautologically true. (obviously, I am hoping for
the latter).
Kenneth Doyle
t:
So according to you, you've proved that it's possible for a
program to determine if a non-Turing-complete program halts?
Sander Bruggink
[Will Twentyman wrote:]
>>It would be nice if they mentioned the restriction that the programming
>>language needs to be Turing-Complete for the problem to apply.
>
> halts, I am sure that your specific type of program would be
> included in the universal set of all programs, don't you think?
Of course, but would you halting function be also of that specific type
of program?
Answer: NO, because *that* is what Turing proved.
groente
-- Sander
Peter Olcott
"Sander Bruggink" <bruggink.at...@no.spam.please> wrote in message
news:cd883j$dog$1...@husserl.admin.phil.uu.nl...
Note please stay within the restriction of the Possible Bases
for Refutation section.
Sander Bruggink
> Note please stay within the restriction of the Possible Bases
> for Refutation section.
Why should I? There are a zillion "Possible Bases for Refutation" you've
not put in that section.
groente
-- Sander
George Greene
> "George Greene" <gre...@greeneg-cs.cs.unc.edu> wrote in message news:xespt6y...@greeneg-cs.cs.unc.edu...
> > "Peter Olcott" <olc...@worldnet.att.net> writes:
> > : To say that my proof is incorrect because it is not framed
> > : within the context of a Turing Machine does not form a valid
> > : refutation of my claim.
> >
> > IT DOES SO, TOO, DUMBASS.
>
> I know you are, but what am I?
> (But only for your unprofessional rude behavior,)
>
> > "The Halting Problem" IS ABOUT Turing Machines.
> > It is NOT about "processes" with "memory" that can
> > "read screens".
>
> Try this more general definition from the National Institute of Standards and Technology.
No.
> This will now be my official definition.
No, it won't.
There is only one definition Turing's Halting Problem
and it (obviously) comes from Turing, NOT NIST.
George Greene
But the whole point, there, is you said "(von Neumann)".
You introduced some LOGICAL DEFINITIONAL CONSTRAINT on what
a PROGRAM is. OLCOTT'S FORMULATION *DOESN'T* do that!
The relevant point (For purposes of this discussion) is that
OF COURSE you can design a MORE powerful computation paradigm
that can correctly answer all halting questions for LESS
powerful paradigms. If you use something as ambiguous as
"program" then you don't get the LEVELS specified clearly enough
to produce the issue. In the case of Turing's Halting Problem,
no *TM* can answer all the (TM,w) halting questions correctly,
but obviously there could be something OTHER than a TM that
could answer them (the issue here is just avoiding Russell's
paradox, which is what is actually happening). IF the things that
Olcott's "solution" could range over are not restricted to be TMs
then obviously he is RIGHT in saying that one of them could
"solve the halting problem". The fact that preserving the analogy
would then require it to also solve halting for things LIKE ITSELF
(and therefore unlike TMs) is of course lost on him.
No Way
On Tue, 13 Jul 2004 23:31:58 GMT, "Peter Olcott" <olc...@att.net>
wrote:
>Most recently updated version of this informal proof will be posted on this
>link:
>http://home.att.net/~olcott/halts.html
>
>The goal of this proof is to refute the Halting Problem's conclusion:
I would imagine that the goal of your proof would not be a certain
conclusion. I would image that the goal of your proof is to
demonstrate 'Da Truth'(tm) and that you think 'Da Truth' refutes the
Halting Problem's conclusion.
>(paraphrase)
>{It is impossible to construct a program that can determine if every program
>halts.}
I can construct such a program... in BASIC!!! :)
10 Print "Not every programs halt."
20 Goto 10
And there you have it...
You probably want to disprove the following (I'm paraphrasing as well
:P ):
It is impossible to construct a program that has a program and the
inputs of that program as its input and is then able to determine
whether the given program will halt on the given input for all
possible programs and inputs.
>This informal proof depends upon the terminology of this link
>http://www.netaxs.com/people/nerp/automata/halting2.html
>to be understood.
>
>This version of the Halting Problem is supposed to be analogous to every
>other version,
It might be supposed to be, but the problem is that it isn't.
> thus valid refutations of this version should equally apply
>(with adaptation) to all other versions.
>
>Process:
>A running program in memory.
>
>Static Program:
>ASCII text that represents the source code of the program that can be edited
>and compiled.
>
>Assumptions:
>(1) No process has any access to read the screen data.
>
>(2) The WillHalt() process is located in protected memory, and any access to
>this memory by other processes causes a memory protection fault error.
Open WillHalt.cpp in your code editor, add code that will make the
program go into an infinite loop as soon as the WillHalt code
determines that the input halts (for instance right before it would
print to the screen), save as WillHaltInDisguise.cpp, compile. See the
problem?
The fact that WillHalt can't be accessed is totaly irrelevant. What
you want is to add the following rule to your system: You are not
allowed to build programs that determine what WillHalt would output
and then do the exact opposite of what WillHalt would output.
The problem is that adding this rule (which you do more or less),
makes this no longer 'the halting problem' (as already said elsewhere,
the halting problem is really about Turing machines, so this was never
really 'the halting problem' anyway...).
It also begs the question why you would introduce a much more
restricting rule? Why not simple add the rule "You are not allowed to
build machines that are nonhalting"?
>Body Of Proof
>The basis of the original proof is a mechanism comparable to the
>LoopIfHalts() function. If this basis could be disabled, then the original
>proof would lose its basis, and fail.
the 'original proof' does have to content with the situation that the
LoopIfHalts() function exists. Making the LoopIfHalt() impossible is
simply changing the given situation (adding a rule as said above) and
the 'original proof' is unaffected by anything that follows from the
change (as it only says something about the original situation).
>The LoopIfHalts() function depends upon access to the return value of the
>WillHalt() function.
Yes, in the text as given it does, but as shown above, it doesn't have
to.
> If every possible access to this return is completely
>denied to every other program, then LoopIfHalts() can not possibly effect
>the WillHalt() function. LoopIfHalts() would be unable to "loop if halts".
Yes, but that's adding a rule (as said above).
>Simple Method
>A simple way to eliminate access to the return value of WillHalt() is to
>only put this return value on the screen, (and nowhere else) and not allow
>any process read access to the screen data. This would of course also
>require that the WillHalt() function not return a value to its caller.
Since WillHalt must work for every program that can be constructed, it
must also work for a program that does exactly the same as WillHalt by
having the same code, but then that program has some extra code that
does exactly the opposite of what the WillHalt-code predicts.
The problem has nothing to do with 'having access'.
>Possible Bases For Refutation
>It seems that the only possible way to refute this proof would have to take
>the form of preventing my unmodified version of WillHalt() from working
>correctly.
You don't have to prevent anything... WillHalt() cannot exist. The
only way of preventing that WillHalt() cannot exist is by adding a
restriction to the type of programs you are allowed to build. This
still doesn't garantee that WillHalt() then exists, but at least then
there is a chance that it exists.
> Any changes made to the WillHalt() function will probably prove
>fruitless for the following reasons:
>Halting can be determined by my original unmodified version of Willhalt()
>for every program, including those based on WillHalt().
This is simply not true (as shown above). Simply build a program that
has the same code as WillHalt and then make it do the opposite of the
outcome of that code. This program can always be build if you can
build WillHalt (unless you are restricting yourself in someway).
> The LoopIfHalts()
>function is now bound to fail because WillHalt() does not return the boolean
>value that it requires.
Not relevant. Returning values has nothing to do with this...
> Although changes can be make to WillHalt() such that
>it can no longer determine if a program (including itself) will halt, my
>original unmodified version would be able to correctly make this
>determination for these programs.
No, it would not (Since you can always write a program that can 'fool'
WillHalt).
I hope this helps you in your quest for truth... but I'm not counting
on it... BTW you might want to go to the library and read about this
stuff... Not to learn how it really works of course, but just to know
what the rest of the world thinks... you know, "if you know the enemy
and know yourself, the victory is not at risk. "
Kent Paul Dolan
[more bogus misunderstandings of how computer theory proofs work]
Well, your posting has been out mere moments, and already
there have been two completely competent refutations.
Again.
One should learn from this:
1) Everyone hates Peter and is trying to meke him feel bad.
2) The whole computer theory community is trying to suppress
Peter's science-overturning results.
3) Peter is wrong.
Choose one from above list _____.
xanthian.
--
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG
G. Frege
<xant...@well.com> wrote:
>
> 1) Everyone hates Peter and is trying to make him feel bad.
> 2) The whole computer theory community is trying to suppress
> Peter's science-overturning results.
> 3) Peter is wrong.
>
> Choose one from above list _____.
>
1? 2?
F.
>parr(*>
| Most recently updated version of this informal proof
| will be posted on this link:
| http://home.att.net/~olcott/halts.html
|
| The goal of this proof is to refute the Halting
| Problem's conclusion:
| {It is impossible to construct a program that can
| determine if every program halts.}
|
| this link
| http://www.netaxs.com/people/nerp/automata/halting2.html
| to be understood.
|
I have read your page and the two referenced pages. I have also read
many of the comments on it, and your responses, but not all. I won't
rake any of that over, although I'm happy to acknowledge I have
stolen freely from ideas in the posts of others.
So let's revisit:
http://www.netaxs.com/people/nerp/automata/halting2.html
And let us suppose we have a machine (not necessarily a TM)
'WillHaltPO(M,w)' defined in the way you indicated, i.e., it displays
its result on a screen and does not return a result, and is shielded
from all prying by being in protected memory. It has all the
refinements which you have added, including the random determination
of which displayed character will indicate 'WillHalt'. Note that it
has a different name from the one supposed in .../halting2. No-one,
except the author, knows the code.
As you correctly point out, it is no longer possible to prove, by the
classical method outlined in '.../halting2.html' that WillHaltPO(M,w)
cannot exist. Further, no-one has proved by any other method, to
your satisfaction, that WillHaltPO(M,w) cannot exist.
However, that does not prove it is possible to create
WillHaltPO(M,w). In the absence of code for such a program, we
simply don't know one way or the other.
Restating those two positions:
To show that the Halting Problem Conclusion has not
been refuted, it is still necessary to show that
WillHaltPO(M,w) cannot exist.
In order to refute the Halting Problem conclusion
fully, it is still necessary to prove the existence
of WillHaltPO(M,w).
Do you agree so far?
I feel it's better to approach this one step at a time. If you agree
that you have not yet proved existence, we can go on to the next
step; otherwise, I have a completely different approach which I am
happy to develop.
--
)>==ss$$%PARR(º> Parr
Peter Olcott
> inputs of that program as its input and is then able to determine
> whether the given program will halt on the given input for all
> possible programs and inputs.
That is what I have refuted.
> The fact that WillHalt can't be accessed is totaly irrelevant. What
> you want is to add the following rule to your system: You are not
> allowed to build programs that determine what WillHalt would output
> and then do the exact opposite of what WillHalt would output.
That would not be a proof. What I did instead was enforce
this such that it is now impossible to permanently circumvent.
It seems that there is no possible way to circumvent my
security that can not be disabled.
> >The LoopIfHalts() function depends upon access to the return value of the
> >WillHalt() function.
>
> Yes, in the text as given it does, but as shown above, it doesn't have
> to.
So you can make a way that will do the opposite of what
WillHalt() determines even if access to what WillHalt()
determines is made impossible? Nice trick, I don't buy it.
> Yes, but that's adding a rule (as said above).
No its not, as I said above.
> Since WillHalt must work for every program that can be constructed, it
> must also work for a program that does exactly the same as WillHalt by
> having the same code, but then that program has some extra code that
> does exactly the opposite of what the WillHalt-code predicts.
I will address this on my website. The answer takes too much
work to repeat over and over. It will probably be
Answers to Frequent Objections (2).
> You don't have to prevent anything... WillHalt() cannot exist. The
> only way of preventing that WillHalt() cannot exist is by adding a
> restriction to the type of programs you are allowed to build. This
> still doesn't garantee that WillHalt() then exists, but at least then
> there is a chance that it exists.
By changing bool WillHalt() to void WillHalt() the LoopIfHalts()
function is no longer even syntactically correct. It won't even compile.
I am not merely saying please don't build a LoopIfHalts() function.
I am saying I have made LoopIfHalts() unable to possibly function.
If you make LoopIfHalts() able to function you have not shown
that solving the Halting Problem is impossible, you merely changed
my way that would work every time into a way that no longer works.
In other words instead of merely changing my method into a method
that does not work, a correct refutation would have to show a way
that makes my method impossible. In other words finding a way
around my security does not refute my method. Only if you can
find a way around my security that can not possibly be fixed, will
you have actually refuted my claims.
Peter Olcott
> However, that does not prove it is possible to create
> WillHaltPO(M,w). In the absence of code for such a program, we
> simply don't know one way or the other.
>
> Restating those two positions:
> To show that the Halting Problem Conclusion has not
> been refuted, it is still necessary to show that
> WillHaltPO(M,w) cannot exist.
>
> In order to refute the Halting Problem conclusion
> fully, it is still necessary to prove the existence
> of WillHaltPO(M,w).
>
> Do you agree so far?
I would say that proving that their proof does not prove
what the conclusion concludes would be a complete refutation.
X ="A Solution to the Halting Problem can not possibly exist."
You say that you proved X.
I prove that you did not prove X.
news...@comcast.net
No, you proved that a MODIFICATION of the original proof doesn't
prove X. That says absolutely nothing about the original proof (which
is perfectly valid).
--
That's News To Me!
news...@comcast.net
>parr(*>
news:8fa7d179d429a1b0108...@mygate.mailgate.org...
| "Peter Olcott" <olc...@att.net> wrote:
|
| [more bogus misunderstandings of how computer theory proofs work]
|
| Well, your posting has been out mere moments, and already
| there have been two completely competent refutations.
Peter needs proof which he can understand.
--
)>==winKING(º> Parr
>parr(*>
news:H1ZJc.102348$OB3....@bgtnsc05-news.ops.worldnet.att.net...
OK
You believe you have proved the existence of WillHaltPO(M,w). And
that it's just ordinary software. It has the following properties:
1. It can't work if its code were known.
2. It can't work if its output could be
accessed by another program.
3. It can't work unless it is armed with a
random number generator which allows it to
speak in code to its user.
OK
Let's get another point clarified before we continue.
Your program needs a random number generator to make it work
successfully.
Is your rng software based? Remember that software based rngs are
deterministic and can be predicted.
--
)>==ss$$%PARR(º> Parr
>parr(*>
news:dAZJc.95638$%_6.5722@attbi_s01...
Patience. This route was followed before.
--
)>==ss$$%PARR(º> Parr
No Way
<olc...@worldnet.att.net> wrote:
>> The fact that WillHalt can't be accessed is totaly irrelevant. What
>> you want is to add the following rule to your system: You are not
>> allowed to build programs that determine what WillHalt would output
>> and then do the exact opposite of what WillHalt would output.
>
>That would not be a proof.
Well, it wouldn't be a proof for a general statement about WillHalt
(which was basically my point), but it does proof that if you add a
certain restriction you can determine if a certain group of
'functions' will halt or not.
>What I did instead was enforce
>this such that it is now impossible to permanently circumvent.
>It seems that there is no possible way to circumvent my
>security that can not be disabled.
Decompile WillHalt (or simply get the source code from somewhere), add
code that will make it do the opposite of what WillHalt predicts,
recompile as LoopIfHalts.
Since the code that determines what WillHalt will output on the input
is the same in both programs, the outcome of that piece of code will
be the same in both programs (if it weren't the piece of code wouldn't
do what it is supposed to do).
>> >The LoopIfHalts() function depends upon access to the return value of the
>> >WillHalt() function.
>>
>> Yes, in the text as given it does, but as shown above, it doesn't have
>> to.
>
>So you can make a way that will do the opposite of what
>WillHalt() determines even if access to what WillHalt()
>determines is made impossible?
Yes (see decompile/recompile above).
>Nice trick, I don't buy it.
Which is rather interesting, because Turing Machines don't use
functions at all. If you think your situation is equivalent to the TM
situation, it must be possible to avoid functions.
>> Yes, but that's adding a rule (as said above).
>No its not, as I said above.
Just saying that you don't do this and actually not doing so are two
different things. You add the condition that there cannot be a program
that does exactly the opposite of what WillHalt predicts.
>> Since WillHalt must work for every program that can be constructed, it
>> must also work for a program that does exactly the same as WillHalt by
>> having the same code, but then that program has some extra code that
>> does exactly the opposite of what the WillHalt-code predicts.
>
>I will address this on my website. The answer takes too much
>work to repeat over and over. It will probably be
>Answers to Frequent Objections (2).
I just looked, but it wasn't there yet, so I can't comment on it.
>By changing bool WillHalt() to void WillHalt() the LoopIfHalts()
>function is no longer even syntactically correct.
Irrelevant. You can still create a LoopIfHalts() that is syntactivally
correct. And 'your' problem is that you will always be able to do so
unless you add some rule that doesn't allow this (such as, but not
limited to, no inifinite loops are allowed/possible, there may not be
two programs whose answer depends on each other's outcome, etc.).
> It won't even compile.
Explain to me why you are unable to adjust the source code of
WillHalt? (Perhaps because you entered your rule into your compiler?)
>I am not merely saying please don't build a LoopIfHalts() function.
>I am saying I have made LoopIfHalts() unable to possibly function.
If that were even the case (which it is not), you've done so by adding
an extra rule which is not in 'the halting problem'.
>If you make LoopIfHalts() able to function you have not shown
>that solving the Halting Problem is impossible, you merely changed
>my way that would work every time into a way that no longer works.
Your way 'works' everytime, because you've added restrictions (which
makes it not equivalent to 'the halting problem'). Your way simply
says that for some programs it is possible to determine whether they
halt or not. Your way does not make a claim about a program that can
examine all other programs (and give the correct response).
>In other words instead of merely changing my method into a method
>that does not work, a correct refutation would have to show a way
>that makes my method impossible.
Your method is not equivalent to 'the halting problem'. It is
therefore not a refutation of 'the halting problem'. On top of that,
you've failed to show why LoopIfHalts cannot exist.
> In other words finding a way
>around my security does not refute my method.
> Only if you can
>find a way around my security that can not possibly be fixed, will
>you have actually refuted my claims.
Explain to me why the decompile/recompile trick doesn't always work?
The Ghost In The Machine
<no_...@aol.com>
wrote
on Fri, 16 Jul 2004 22:48:33 +0200
<8lfgf0t79do2l3dqb...@4ax.com>:
5!
(3 sir!)
:-)
--
#191, ewi...@earthlink.net -- insert random holy artifact from Antioch here
It's still legal to go .sigless.
Taneli Huuskonen
Hash: SHA1
En la afisho <2VYJc.102313$OB3....@bgtnsc05-news.ops.worldnet.att.net>
"Peter Olcott" <olc...@worldnet.att.net> skribis:
>In other words instead of merely changing my method into a method
>that does not work, a correct refutation would have to show a way
>that makes my method impossible. In other words finding a way
>around my security does not refute my method. Only if you can
>find a way around my security that can not possibly be fixed, will
>you have actually refuted my claims.
Security is futile. You will be simulated.
Seriously, everyone and their dog have been trying to tell you there is
indeed a way around your security that cannot possibly be fixed, which
is simply that whatever breaks an intentionally unsecured version will
also break the original version, but you keep denying it. Instead of
continuing this silly playground-style arguing, let's run some actual
code and see what happens.
So, I'll re-issue my challenge and make it even easier for you by
explaining how I'm going to respond. I'll take your programme that
accepts some text, say, on its standard input, somehow or other
determines whether the input is "good" or "bad", and communicates the
result to a human. (A programme solving a special case of the Halting
Problem would say the input is good iff it is the source of a programme
that halts without accepting any input.) I'll make a domesticated
version of your programme that, when called with a string argument,
returns the decision about its goodness to the caller. Then I'll have
my programme call that watered-down function and print out a message
proclaiming the opposite of its decision. Since I'd promised my
programme would work without accepting any input, I'll have to add some
code that generates my programme's own source; that's an old,
well-known trick.
The point is: my programme, which uses this intentionally broken version
of your programme, will defeat your original one. Any security features
you may possibly have will be irrelevant. It's you who's claiming
something might possibly be done about it, so the onus is on you.
Taneli Huuskonen
-----BEGIN PGP SIGNATURE-----
Version: PGPfreeware 5.0i for non-commercial use
Charset: noconv
iQA/AwUBQPjbO1+t0CYLfLaVEQJW8gCgpxvdRfEiqvTG3B9/H38uLvaluZ0AoNEB
KATQfGXluhbAjeIe40g9wnwp
=R0fz
-----END PGP SIGNATURE-----
--
All messages will be PGP signed, | I am not a profoundly
encrypted mail preferred. Keys: | brilliant genius, I am
http://www.helsinki.fi/~huuskone/ | just barely a genius.
Guantánamo macht frei! | -- Peter Olcott
>parr(*>
news:Oh_Ic.91468$OB3....@bgtnsc05-news.ops.worldnet.att.net...
| Most recently updated version of this informal proof will be posted
on this
A further question:
Have you created a successful 'WillHalt(M,w)' function?
--
)>==ss$$%PARR(º> Parr
Peter Olcott
> prove X. That says absolutely nothing about the original proof (which
> is perfectly valid).
>
> --
>
> That's News To Me!
> news...@comcast.net
Method of this Proof
X = The solution to the Halting Problem
Y = The basis of the original proof
Z = The basis of this proof
Structure of Original Proof---->Y makes X impossible
Structure of This Proof--------->Z makes Y impossible
http://home.att.net/~olcott/halting/index.html
Peter Olcott
> |
> | You say that you proved X.
> | I prove that you did not prove X.
>
> OK
>
> You believe you have proved the existence of WillHaltPO(M,w). And
> that it's just ordinary software. It has the following properties:
>
> 1. It can't work if its code were known.
> 2. It can't work if its output could be
> accessed by another program.
It won't always work when its output is accessable by
other programs. Its output can be made impossible
to access by other programs.
> 3. It can't work unless it is armed with a
> random number generator which allows it to
> speak in code to its user.
No this is no longer required. I have simplified
my method eliminating the need for a hardware RNG.
Peter Olcott
> >this such that it is now impossible to permanently circumvent.
> >It seems that there is no possible way to circumvent my
> >security that can not be disabled.
>
> Decompile WillHalt (or simply get the source code from somewhere), add
> code that will make it do the opposite of what WillHalt predicts,
> recompile as LoopIfHalts.
http://home.att.net/~olcott/halting/index.html#objection02
> Since the code that determines what WillHalt will output on the input
> is the same in both programs, the outcome of that piece of code will
> be the same in both programs (if it weren't the piece of code wouldn't
> do what it is supposed to do).
http://home.att.net/~olcott/halting/example.html
That is not true examine this page closely, and see for yourself.
> Which is rather interesting, because Turing Machines don't use
> functions at all. If you think your situation is equivalent to the TM
> situation, it must be possible to avoid functions.
http://home.att.net/~olcott/halting/index.html#objection01
See this link to see why any mention of Turing Machines
is made moot.
> Your way 'works' everytime, because you've added restrictions (which
> makes it not equivalent to 'the halting problem'). Your way simply
> says that for some programs it is possible to determine whether they
> halt or not. Your way does not make a claim about a program that can
> examine all other programs (and give the correct response).
If it is a given that I can make access to the results of WillHalt()
impossible for any specific program to access, then I have
disproved the Halting Problem. The fact that you can decompile
my method any make one instance of it no longer function does
not in any way refute the general case. You would have to make
every possible instance of my WillHalt() simultaneously not function
in order to correctly refute my proof.
> Explain to me why the decompile/recompile trick doesn't always work?
I just did.
Peter Olcott
"Taneli Huuskonen" <huus...@cc.helsinki.fi> wrote in message
news:cdam0e$ts5$1...@sirppi.helsinki.fi...
> -----BEGIN PGP SIGNED MESSAGE-----
> Hash: SHA1
>
> En la afisho <2VYJc.102313$OB3....@bgtnsc05-news.ops.worldnet.att.net>
> "Peter Olcott" <olc...@worldnet.att.net> skribis:
>
> >In other words instead of merely changing my method into a method
> >that does not work, a correct refutation would have to show a way
> >that makes my method impossible. In other words finding a way
> >around my security does not refute my method. Only if you can
> >find a way around my security that can not possibly be fixed, will
> >you have actually refuted my claims.
>
> Security is futile. You will be simulated.
In order to correctly refute my method you would have to simultaneously
circumvent the security on every possible instance of it. Unless and until
every single instance is disabled, the method still works. If it only works
on a single machine locked in a bank vault, then it still works.
Peter Olcott
> > 1) Everyone hates Peter and is trying to make him feel bad.
> > 2) The whole computer theory community is trying to suppress
> > Peter's science-overturning results.
> > 3) Peter is wrong.
4) This problem has already (seemingly) been decided for sixty-eight
years, and this adds significant bias to the judgment of most people's
evaluation of what Peter is saying.
Hans Hüttel
Since I am deeply impressed by the mathematical maturity of a
contributor to sci.logic and comp.theory, who shall remain nameless, I
have decided to do a little number theory (which is not really my area,
but...)
Mathematicians generally claim that there do not exist even prime
numbers greater than 2. However, I have found a FLAW in their so-called
proof. Their "proof" goes as follows:
Let n be an even integer where n > 2. Since n is even, n must be of the
form 2k for some k, where k > 2. But this means that n has a nontrivial
factor and therefore cannot be prime.
But assume that we do not allow factorization of composite integers! We
distinguish between:
- Public factors: An integer f is a public factor of n, if f is known
to be a factor of n
- Secret factors: An integer f is a secret factor of n, if f is a
factor of n but there is no way of determining if f is a factor (and
division does not count - remember, we are assuming that factorization
is illegal!!)
Now the proof breaks down, since there can only be secret factors. We
can no longer be sure that 2 is a factor of an even number, as
factorization is assumed to be impossible! Thus it is very likely that
some even numbers are primes.
In fact, I think it may now well be the case that there are infinitely
many even primes. I am even fairly sure that they can be randomly
generated (by a secret prime number generator).
Hans
Laury
Parr wrote...
| > You believe you have proved the existence of WillHaltPO(M,w).
And
| > that it's just ordinary software. It has the following
properties:
| >
| > 1. It can't work if its code were known.
| No I disagree with this.
|
| > 2. It can't work if its output could be
| > accessed by another program.
|
| It won't always work when its output is accessable by
| other programs. Its output can be made impossible
| to access by other programs.
|
| > 3. It can't work unless it is armed with a
| > random number generator which allows it to
| > speak in code to its user.
|
| No this is no longer required. I have simplified
| my method eliminating the need for a hardware RNG.
|
| http://home.att.net/~olcott/halting/index.html
OK
Regarding 1:
I understand your 'No I disagree with this.' to
mean:
"WillHaltPO(M,w) can always determine whether any
arbitrary program, defined by M, will halt when
presented with input w. This will be the case
even if M includes the code of WillHaltPO(M,w)."
Please confirm this is a correct understanding.
Regarding 2:
I understand 'won't always work when its output is
accessible...' to mean:
"WillHaltPO(M,w) can always determine whether any
arbitrary program, defined by M, will halt when
presented with input w, provided its output
cannot be accessed by another program."
Please confirm this is a correct understanding.
Regarding 3.
My mistake, I thought your statement of 10 Jul
superseded the quoted page. I have now read the
updated page with URL as above. I understand
therefore:
"WillHaltPO(M,w) is deterministic and will always
return the same result when presented with a given
input pair of M and w."
--
)>==ss$$%PARR(º> Parr
Peter Olcott
> Regarding 1:
> I understand your 'No I disagree with this.' to
> mean:
> "WillHaltPO(M,w) can always determine whether any
> arbitrary program, defined by M, will halt when
> presented with input w. This will be the case
> even if M includes the code of WillHaltPO(M,w)."
>
> Please confirm this is a correct understanding.
The above shgould make it clearer
> Regarding 2:
> I understand 'won't always work when its output is
> accessible...' to mean:
> "WillHaltPO(M,w) can always determine whether any
> arbitrary program, defined by M, will halt when
> presented with input w, provided its output
> cannot be accessed by another program."
>
> Please confirm this is a correct understanding.
Right. The key point here is not that it is limited
to only those cases where the output is inaccessible,
such that another program could merely ignore this
limitation, but, this limit can be completely enforced
thus making it impossible for another program to
circumvent this restriction.
> Regarding 3.
> My mistake, I thought your statement of 10 Jul
> superseded the quoted page. I have now read the
> updated page with URL as above. I understand
> therefore:
> "WillHaltPO(M,w) is deterministic and will always
> return the same result when presented with a given
> input pair of M and w."
Unless its security has been circumvented in one case
and not circumvented in another case. In this case the
former situation might be undecidable, whereas the latter
situation would be decidable.
Taneli Huuskonen
Hash: SHA1
En la afisho <nkeKc.271570$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
"Peter Olcott" <olc...@worldnet.att.net> skribis:
>"Taneli Huuskonen" <huus...@cc.helsinki.fi> wrote in message
[...]
>> Security is futile. You will be simulated.
>In order to correctly refute my method you would have to simultaneously
>circumvent the security on every possible instance of it. Unless and until
>every single instance is disabled, the method still works. If it only works
>on a single machine locked in a bank vault, then it still works.
The method I outlined in the part that you removed would do exactly
that. Well, I'd say that all security features would be not really
circumvented but removed or ignored, depending on what's needed to
create the non-secure callable version. You could certainly have the
secure version run on a single machine on the far side of the Moon if
you wished; since my programme would always produce the same result,
the physical surroundings would have no significance whatsoever.
My challenge still stands: show me _one_ security feature that has a
cat in hell's chance of making a difference.
Taneli Huuskonen
-----BEGIN PGP SIGNATURE-----
Version: PGPfreeware 5.0i for non-commercial use
Charset: noconv
iQA/AwUBQPowGV+t0CYLfLaVEQLxZwCgyI98TvHpq7L0uAxevEHhCi1MYmkAoLkM
KgZTiGXdjYr6m7YdEWFmfq9S
=iEqj
No Way
<olc...@worldnet.att.net> wrote:
>http://home.att.net/~olcott/halting/index.html#objection02
It says: "The possibility of creating one or more instances of
WillHalt() that permit LoopIfHalts() to function does not refute this
method."
But it does. Your method is founded on the idea that LoopIfHalts
cannot be constructed. As soon as it is shown that that is possible,
your method breaks down.
"In other words defeating the security in less than every possible
case does not prove that this method does not work."
And you think the security wasn't broken in less than every possible
case? With any version of WillHalt you can come up with, I can come up
with a version of a LoopIfHalts (and thus a version of
LoopIfHaltsOnItself and thus a version of Impossible).
"One single case where the security is not circumvented proves that
the idea still works."
?
>> Since the code that determines what WillHalt will output on the input
>> is the same in both programs, the outcome of that piece of code will
>> be the same in both programs (if it weren't the piece of code wouldn't
>> do what it is supposed to do).
>
>http://home.att.net/~olcott/halting/example.html
>That is not true examine this page closely, and see for yourself.
First of all, why does the WillHalt function (in the 'original')
contain an 'unknown' option? That WillHalt should be like this:
bool WillHalt(string SourceCode, string InputData)
{
if (TheProgramWillHalt(SourceCode, InputData))
return TRUE;
else
return FALSE;
}
Secondly, in your new WillHalt system, why won't I be able to build
the following?
void LoopIfHalts(string SourceCode, string InputData)
{
if (TheProgramWillHalt(SourceCode, InputData))
while (TRUE);
else
return
}
BTW I'm beginning to wonder whether you even understood the basis of
the halting problem proof. You do understand what the outline of the
proof is, right?
* The existence of a WillHalt program (a program that correctly
predicts whether the input program halts or not on a certain input)
implies the existence of a LoopIfHalts program (a program that goes
into a loop if WillHalt would predict that the input program would
halt).
* The existence of a LoopIfHalts program implies the existence of a
LoopIfHaltsOnItself program.
* LoopIfHaltsOnItself cannot work properly because it will be unable
to work properly on itself (If LoopIfHaltsOnItself would halt, it
would have to go into a loop and vice versa).
* So LoopIfHaltOnItself cannot exist.
* Since the existence of LoopIfHalts implies the existence of
LoopIfHaltsOnItself, LoopIfHalts cannot exist.
* Since the existence of Willhalt implies the existence of
LoopIfHalt,Willhalt cannot exist either.
What you are trying to do, is find a way around the first step. You
want to make the existence of LoopIfHalts impossible. You try to do
this by adding a rule to the system. However by adding that rule, the
problem is no longer the 'halting problem'.
>> Which is rather interesting, because Turing Machines don't use
>> functions at all. If you think your situation is equivalent to the TM
>> situation, it must be possible to avoid functions.
>
>http://home.att.net/~olcott/halting/index.html#objection01
>See this link to see why any mention of Turing Machines
>is made moot.
You just saying that doesn't make it true. If your 'proof' is a way to
show that the conclusion of 'the halting problem' is incorrect in
general, it should also be able to be applied to Turing Machines.
>If it is a given that I can make access to the results of WillHalt()
>impossible for any specific program to access, then I have
>disproved the Halting Problem.
No, you will have changed the problem to something else by adding a
rule (No program is allowed to exist that disproves that WillHalt can
exist).
>The fact that you can decompile
>my method any make one instance of it no longer function does
>not in any way refute the general case.
> You would have to make
>every possible instance of my WillHalt() simultaneously not function
>in order to correctly refute my proof.
Why would I have to do that?
>> Explain to me why the decompile/recompile trick doesn't always work?
>I just did.
No, you didn't.
>parr(*>
|
| > Regarding 1:
| > I understand your 'No I disagree with this.' to
| > mean:
| > "WillHaltPO(M,w) can always determine whether any
| > arbitrary program, defined by M, will halt when
| > presented with input w. This will be the case
| > even if M includes the code of WillHaltPO(M,w)."
| >
| > Please confirm this is a correct understanding.
| http://home.att.net/~olcott/halting/example.html
| The above shgould make it clearer
I read that to indicate that to confirm:
"WillHaltPO(M,w) can always determine whether any
arbitrary program, defined by M, will halt when
presented with input w. This will be the case
even if M includes the code of WillHaltPO(M,w)."
To restate that, I understand that the input code string, M, to the
successsful WillHalt may include any arbitrary string whatsoever.
Please confirm that I understand that simple that so that I may then
go on to understand the rest of your costruction.
| > Regarding 2:
| > I understand 'won't always work when its output is
| > accessible...' to mean:
| > "WillHaltPO(M,w) can always determine whether any
| > arbitrary program, defined by M, will halt when
| > presented with input w, provided its output
| > cannot be accessed by another program."
| >
| > Please confirm this is a correct understanding.
|
| Right. The key point here is not that it is limited
| to only those cases where the output is inaccessible,
| such that another program could merely ignore this
| limitation, but, this limit can be completely enforced
| thus making it impossible for another program to
| circumvent this restriction.
Good, thanks for an explicit response.
So I would be right in thinking that if WillHaltPO(M.w) were to be
running in a computer in which no other program whatsoever is
running, it will work. To clarify what I mean by running 'alone', I
include within WillHaltPO all code necessary to access its input and
make its output, and no other.
Please also congfirm tha WillHaltPO will not be prevented from
working by running it in isolation.
|
| > Regarding 3.
| > My mistake, I thought your statement of 10 Jul
| > superseded the quoted page. I have now read the
| > updated page with URL as above. I understand
| > therefore:
| > "WillHaltPO(M,w) is deterministic and will always
| > return the same result when presented with a given
| > input pair of M and w."
|
| Unless its security has been circumvented in one case
| and not circumvented in another case. In this case the
| former situation might be undecidable, whereas the latter
| situation would be decidable.
I believe you just confirmed that WillHaltPO(M,w) is a deterministic
program which always returns the same result when presented with a
given input pair of M and w, subject to the security condition which
I restated as '2.'
---
I look forward to confirmation of my understanding requested under
points 1 & 2.
--
)>==ss$$%PARR(º> Parr
Donald Roby
No. As others have argued, but failed to convince you, the assumed
existence of a WillHalt() function with your constraints implies the
existence of a WillHalt() function without your constraints, and leads to
the constradiction you're claiming to evade.
Indeed, your "example" code references such a function itself, though
you're confusing yourself by giving it a different name.
Hiding it inside a program with your constraints does nothing whatsoever.
If it exists, then it exists independently of your contrivances and
implies the existence of the LoopIfHalts function, which leads to a
contradiction.
Peter Olcott
> >In order to correctly refute my method you would have to simultaneously
> >circumvent the security on every possible instance of it. Unless and until
> >every single instance is disabled, the method still works. If it only works
> >on a single machine locked in a bank vault, then it still works.
>
> The method I outlined in the part that you removed would do exactly
> that. Well, I'd say that all security features would be not really
> circumvented but removed or ignored, depending on what's needed to
> create the non-secure callable version. You could certainly have the
> secure version run on a single machine on the far side of the Moon if
> you wished; since my programme would always produce the same result,
> the physical surroundings would have no significance whatsoever.
Except that my copy on the far side of the moon still represents the
required single counter-example to disprove the statement:
No program can ever be written to determine whether any arbitrary program will halt
Peter Olcott
"No Way" <N...@real.com> wrote in message news:gbakf01kisichoj39...@4ax.com...
> On Sat, 17 Jul 2004 18:29:33 GMT, "Peter Olcott"
> <olc...@worldnet.att.net> wrote:
>
> >http://home.att.net/~olcott/halting/index.html#objection02
>
> It says: "The possibility of creating one or more instances of
> WillHalt() that permit LoopIfHalts() to function does not refute this
> method."
>
> But it does. Your method is founded on the idea that LoopIfHalts
> cannot be constructed. As soon as it is shown that that is possible,
> your method breaks down.
No. as long as a single unmodified copy of the my original program exists
then this single copy still represents the required single counter-example to
disprove the statement:
No program can ever be written to determine whether any arbitrary program will halt
> "One single case where the security is not circumvented proves that
> the idea still works."
Unless you can make my security impossible in all cases, you have
not refuted my position. Even a single case would form the required
single counter-example.
> >http://home.att.net/~olcott/halting/example.html
> >That is not true examine this page closely, and see for yourself.
>
> First of all, why does the WillHalt function (in the 'original')
> contain an 'unknown' option? That WillHalt should be like this:
Because this more clearly represents that actual facts. Most
people assume that if a statement is not true, then it must be
false. This assumption is incorrect.
There are two programs in the Halting Problem:
(1) The Analyzer
(2) The Analyzed
The Analyzer is not limited to a Turing Machine. The Analyzed
can include a Turing Machine. (I just updated my website with this).
> >If it is a given that I can make access to the results of WillHalt()
> >impossible for any specific program to access, then I have
> >disproved the Halting Problem.
>
> No, you will have changed the problem to something else by adding a
> rule (No program is allowed to exist that disproves that WillHalt can
> exist).
It is not merely a rule, if I can perfectly enforce it. It was merely
a rule that other programs would be free to disobey, then I would
have proved nothing. Since I have provided a set of ways to make
access to the result of WillHalt() impossible, I have thus disproved
the original Halting Problem.
> >The fact that you can decompile
> >my method any make one instance of it no longer function does
> >not in any way refute the general case.
> > You would have to make
> >every possible instance of my WillHalt() simultaneously not function
> >in order to correctly refute my proof.
>
> Why would I have to do that?
If there exists a single example of my unmodified program, then this creates
the single counter-example required to refute:
{No program can ever be written to determine whether any arbitrary program will halt}
There would be one unmodified program that correctly refutes this statement, even if
every other copy is modified.
Peter Olcott
> "WillHaltPO(M,w) can always determine whether any
> arbitrary program, defined by M, will halt when
> presented with input w. This will be the case
> even if M includes the code of WillHaltPO(M,w)."
>
> To restate that, I understand that the input code string, M, to the
> successsful WillHalt may include any arbitrary string whatsoever.
Not at all, if the string represents an English Poem, then the
string it outside of the domain. It must be a syntactically
correct program. (If it isn't then it won't compile) It does
not have to be semantically correct (there can be bugs in it).
> So I would be right in thinking that if WillHaltPO(M.w) were to be
> running in a computer in which no other program whatsoever is
> running, it will work. To clarify what I mean by running 'alone', I
> include within WillHaltPO all code necessary to access its input and
> make its output, and no other.
I am not sure what you mean here. It is generally difficult to
run a program without an operating system.
> Please also congfirm tha WillHaltPO will not be prevented from
> working by running it in isolation.
If no other programs are running, then there are no other programs
that have access to its results. This is a subtle point though. The actual
case of the Halting Problem is a hypothetical what if, based on
the static (ASCII text) representation of a program.
There are two significant points here:
(1) What if void WillHalt() is run and its security has been circumvented?
Then it is possible for another program to makes its result undecidable.
(2) What if void WillHalt() is run and its security can not possibly be
circumvented in at least one instance for the set of all programs?
Then the Halting Problem has been refuted.
Even if this requires creating a very special hardware / software system, that only
processes Halting Problems, and nothing else. Even if every piece of Software in
the system it burned directly into ROM chips to prevent its modification. One single
instance where access to the result of WillHalt() is made impossible to all other
programs, creates the single valid counter-example disproving:
{No program can ever be written to determine whether any arbitrary program will halt}
> | > Regarding 3.
> | > My mistake, I thought your statement of 10 Jul
> | > superseded the quoted page. I have now read the
> | > updated page with URL as above. I understand
> | > therefore:
> | > "WillHaltPO(M,w) is deterministic and will always
> | > return the same result when presented with a given
> | > input pair of M and w."
> |
> | Unless its security has been circumvented in one case
> | and not circumvented in another case. In this case the
> | former situation might be undecidable, whereas the latter
> | situation would be decidable.
>
> I believe you just confirmed that WillHaltPO(M,w) is a deterministic
> program which always returns the same result when presented with a
> given input pair of M and w, subject to the security condition which
> I restated as '2.'
Yes.
(1) Same Program
(2) Same Input
(3) Same Security
Yields Same Results.
Change any one of the above three, and different results are possible.
Marc Goodman
http://home.att.net/~olcott/halting/example.html
Here is the code for "WillHalt" with line numbers added for
reference:
1 void WillHalt(string SourceCode, string InputData)
2 {
3 if (TheProgramWillHalt(SourceCode, InputData))
4 SecureOutput("The Program Will Halt");
5
6 else if (TheProgramWillNotHalt(SourceCode, InputData))
7 SecureOutput("The Program Will Not Halt");
8
9 else
10 SecureOutput("Security Has Been Breached, Take Corrective Action");
}
Counterproof follows:
If WillHalt exists, then it must either (A) be turing machine
equivalent or (B) not turing machine equivalent.
If (A) is true, then it must be runnable on a turing machine
that simulates the exact execution environment of WillHalt running
on a "normal computer". If such a simulator is run on WillHalt
then either (A1) WillHalt running on a "normal computer" will always
produce the same results as WillHalt running on the simulator, or
(B1) WillHalt will sometimes produce different results running on
a normal computer that it produces running on the simulator.
If (A1) is true, then the simulator will "know" when it is
executing lines 4, 7, or 10 of the WillHalt program. It can
therefore return appropriate results to any calling programs
and is subject to the halting problem. So, the exact simulation
of WillHalt cannot exist, so (A1) cannot be true.
If (B1) is true, then WillHalt must somehow know that in one
case it is running on a stand-alone "normal computer", and in
the other case it is running on an exact simulation of such a
computer. But, by definition, the environment presented to
WillHalt is identical in both cases, so (B1) cannot be true.
Since (A1) cannot be true and (B1) cannot be true, WillHalt
cannot be run on a turing machine simulator, therefore WillHalt
cannot be turing machie equivalent, therefor (A) cannot be true.
If (B) is true, then you have proven it may be possible to construct
a machine more powerful than a turing machine which can always
tell if a turing machine will halt/loop/or unknown. But, this
is tautological, because it's always possible to posit a class
of machines that is more powerful than another class of machines,
and merely positing that such a thing exists a). says nothing
about the limitations of the weaker class (i.e., turing machines)
and b). doesn't in itself constitute proof that such a more
powerful machine exists. Therefore if (B) is true, you haven't
proven anything about turing machines, and you haven't "disproved
the halting problem's conclusion."
Since (A) is false, (B) must be true, therefore you haven't
"disproved the halting problem's conclusion." QED
Daryl McCullough
[stuff deleted]
>Since (A) is false, (B) must be true, therefore you haven't
>"disproved the halting problem's conclusion." QED
Marc, Peter is incapable of following a logical argument. That's
the conclusion I came to after spending several weeks arguing with
him.
What he seems to think now is this: If he doesn't tell you the code
for WillHalt, then you won't be able to tell him the inputs for which
WillHalt gives the incorrect answer. It's about at the level of
"I could pick up a 2000 pound automobile over my head, if I wanted
to. I just don't want to right now."
--
Daryl McCullough
Ithaca, NY
Marc Goodman
> Marc, Peter is incapable of following a logical argument. That's
> the conclusion I came to after spending several weeks arguing with
> him.
Yes, I know that. But I spent 15 minutes thinking about exactly
why his current revision is wrong, so I figured, "what the hell."
Besides, the question of whether or not there's an input that
will cause Peter to halt is still open :). There may still be
an input that will cause Peter's head to explodiate in "Scanners"
fashion, and the very small possibility of a very large payout in
entertainment value is enough to keep me in the game.
And yet, I still don't play the lottery. Go figure.
George Greene
: > PARAphrasing IS NOT acceptable!
: > That "It is impossible to construct a program that can determine if every program
: > : halts" IS NOT the halting problem's conclusion!
: > The Halting Problem is about A TURING MACHINE (NOT a program) that
: > decides whether every TURING MACHINE (on every input) does or doesn't halt!
"Peter Olcott" <olc...@att.net> writes:
: That's right I am sure that you have just proved that the
: National Institutes of Standards and Technology is totally
: off-base.
I haven't even SAID that, let ALONE proved it.
The National Institutes of Standarsd and Technology
ALREADY KNOW that what they are talking about is Turing-Equivalent.
Only YOU are so stupid that you don't know THAT.
: After all everyone (but me) already knows that
: George Greene is the ultimate authority on these matters.
It is not MY authority that is being appealed to here.
Bunches of other people in the room have already told you
that the problem depends on what you called "the analyzer"
and "the analyzed" being the SAME kind of program.
Whether that kind is Turing Machine or a lambda-expression-
evaluator or whatEVER is being used at
: http://www.nist.gov/dads/HTML/haltingProblem.html
is simply irrelevant.
--
--- The history of our nation has demonstrated that separate is seldom, if ever, equal.
--- (Feb.3,2004) Supreme Judicial Court of Massachusetts (4-3), adv.Sen.#2175
George Greene
: > > 1) Everyone hates Peter and is trying to make him feel bad.
: > > 2) The whole computer theory community is trying to suppress
: > > Peter's science-overturning results.
: > > 3) Peter is wrong.
:
: 4) This problem has already (seemingly) been decided for sixty-eight
: years,
No, factually. It was decided by a proof.
: and this adds significant bias to the judgment of most people's
: evaluation of what Peter is saying.
No, and this proves that what Peter is saying is based on his failure
to understand what a proof is, and what a Problem is, and what
a Turing Machine is.
Notwithstanding the treatment at NIST, Peter, do you or do you
not personally, currently, believe that a WillHalt TM could exist?
Out of all the TMs that there are, do you believe that 1 of them actually
DOES correctly decide WillHalt(M,w) for all TM's?
Yes or No?
George Greene
: > However, that does not prove it is possible to create
: > WillHaltPO(M,w). In the absence of code for such a program, we
: > simply don't know one way or the other.
: >
: > Restating those two positions:
: > To show that the Halting Problem Conclusion has not
: > been refuted, it is still necessary to show that
: > WillHaltPO(M,w) cannot exist.
: >
: > In order to refute the Halting Problem conclusion
: > fully, it is still necessary to prove the existence
: > of WillHaltPO(M,w).
: >
: > Do you agree so far?
:
: I would say that proving that their proof does not prove
: what the conclusion concludes would be a complete refutation.
Well, you would be completely full of shit.
Given that Turing sez "No TM does what WillHalt needs
to do in order to deserve its name", THE ONLY thing that
counts as a COMPLETE refutation is YOUR EXHIBITING a TM
that DOES do what WillHalt needs to do, namely, give the
CORRECT answer (from "it halts" or "it doesn't") for
EVERY M,w pair that COULD POSSIBLY be given to it as input.
: X ="A Solution to the Halting Problem can not possibly exist."
:
: You say that you proved X.
No, we say that Turing proved X in 1936.
: I prove that you did not prove X.
THE ONLY way you could prove that is by EXHIBITING A TM
that IS WillHalt. WE'RE WAITING....
Is it Turing-computable how long we'll have to wait?
>parr(*>
| [Parr Wrote 18JUL04 13:24GMT+1]
| > I read that to indicate that to confirm:
| > "WillHaltPO(M,w) can always determine whether any
| > arbitrary program, defined by M, will halt when
| > presented with input w. This will be the case
| > even if M includes the code of WillHaltPO(M,w)."
| >
| > To restate that, I understand that the input code string,
| > M, to the successsful WillHalt may include any arbitrary
| > string whatsoever.
|
| Not at all, if the string represents an English Poem, then
| the string it outside of the domain. It must be a
| syntactically correct program. (If it isn't then it won't
| compile) It does not have to be semantically correct (there
| can be bugs in it).
OK, so I should rephrase that to be:
1. "WillHaltPO(M,w) can always determine whether any
arbitrary, syntactically correct program, defined
by M, will halt when presented with input w.
This will be the case even if M includes the code
of WillHaltPO(M,w)."
Please confirm this is more acceptable.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[regarding 2.]
| > So I would be right in thinking that if WillHaltPO(M.w)
| > were to be running in a computer in which no other
| > program whatsoever is running, it will work. To clarify
| > what I mean by running 'alone', I include within
| > WillHaltPO all code necessary to access its input and
| > make its output, and no other.
|
| I am not sure what you mean here. It is generally difficult
| to run a program without an operating system.
Sorry, I'll try to explain.
I wished to preempt any potential objection (now Frequent Objection
2) based on use of a second instance of the WillHalt process running
in the same machine, or indeed for another instance in another,
communicating, machine.
Your refutation, as I understand it, does not depend on WillHalt
running in a computer with an operating system. If so, it would be a
good idea to clarify this.
| > Please also confirm tha WillHaltPO will not be prevented
| > from working by running it in isolation.
|
| If no other programs are running, then there are no other
| programs that have access to its results. This is a subtle
| point though. The actual case of the Halting Problem is a
| hypothetical what if, based on the static (ASCII text)
| representation of a program.
'Static representation' - exactly so. Then we get no
misunderstandings based on assuming multiple copies of WillHalt are
being run.
| There are two significant points here:
| (1) What if void WillHalt() is run and its security has
| been circumvented?
| Then it is possible for another program to makes its result
| undecidable.
So we prevent that.
| (2) What if void WillHalt() is run and its security can not
| possibly be circumvented in at least one instance for the
| set of all programs?
So we ensure that.
| Then the Halting Problem has been refuted.
I think the the original proof will still be valid for the original,
limited, set of programs. That set does not, of course, include a
successful WillHaltPO(M,w).
|
| Even if this requires creating a very special hardware /
| software system, that only processes Halting Problems, and
| nothing else. Even if every piece of Software in the system
| it burned directly into ROM chips to prevent its
| modification. One single instance where access to the
| result of WillHalt() is made impossible to all other
| programs,
There should be no objection to defining WillHaltOP(M,w) in that way,
especially if it helps to define the the program in a watertight way.
| creates the single valid counter-example
| disproving:
|
| {No program can ever be written to determine whether any
| arbitrary program will halt}
There's a bit more to do before creation such as writing the code.
Being pedantic, I would have put it more like:
It defines one environment (of possibly more than one) which is seen
to be necessary for the creation of a counter-example ... ('the
Single' would be inappropriate because a given functionality can be
implemented in different ways.)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[regarding 3.]
| > I believe you just confirmed that WillHaltPO(M,w) is a
| > deterministic program which always returns the same
| > result when presented with a given input pair of M and w,
| > subject to the security condition which I restated as
| > '2.'
|
| Yes.
| (1) Same Program
| (2) Same Input
| (3) Same Security
| Yields Same Results.
|
| Change any one of the above three, and different results are
possible.
That's clear so, (subject to the conditions discussed
under 1. & 2., we have:
3. "WillHaltPO(M,w), is deterministic and will always
return the same result when presented with a given input
pair of M and w."
~~~~~~~~~~~~~~~~~~~~~~~~
Please could you confirm my understanding under '1.'
~~~~~~~~~~~~~~~~~~~~~~~~
If so, I believe we have arrived at a more robust and idiot-proof
definition of your proposal for WillHalt.
I would then like to work at formalising the rest of your refutation.
This would take the traditional form:
Given [WillHalt defined as in 1., 2., 3. plus other
givens if found necessary during formalisation]
To prove [A program can be written to determine whether
any arbitrary program will halt]
Method [formalisation of your X, Y, & Z and your logic]
Conclusion [...]
QED
--
)>==ss$$%PARR(º> Parr
Peter Olcott
"Marc Goodman" <marc.g...@comcast.net> wrote in message news:40FAAB27...@comcast.net...
http://home.att.net/~olcott/halting/index.html#objection02
Neither the Analyzer nor the Analyzed are limited to Turing Machines
No Way
<olc...@worldnet.att.net> wrote:
> as long as a single unmodified copy of the my original program exists
>then this single copy still represents the required single counter-example to
>disprove the statement:
>No program can ever be written to determine whether any arbitrary program will halt
Duh! Saying that if a program exists that can determine whether any
arbitraty program will halt, the statement is false is not a proof.
The problem is that that program WillHalt cannot exist (because its
existence would imply a program that cannot exist).
>> First of all, why does the WillHalt function (in the 'original')
>> contain an 'unknown' option? That WillHalt should be like this:
>
>Because this more clearly represents that actual facts. Most
>people assume that if a statement is not true, then it must be
>false. This assumption is incorrect.
Are you saying that a program can do something other than halt or not
halt?
>> >If it is a given that I can make access to the results of WillHalt()
>> >impossible for any specific program to access, then I have
>> >disproved the Halting Problem.
>>
>> No, you will have changed the problem to something else by adding a
>> rule (No program is allowed to exist that disproves that WillHalt can
>> exist).
>
>It is not merely a rule, if I can perfectly enforce it. It was merely
>a rule that other programs would be free to disobey, then I would
>have proved nothing.
I'm not disagreeing there... :)
>Since I have provided a set of ways to make
>access to the result of WillHalt() impossible, I have thus disproved
>the original Halting Problem.
No.
First of all, the extra rule doesn't make this the original 'halting
problem'. Secondly, the way you want to enforce it doesn't work.It is
still possible to build a LoopIfHalts, which leads to a
LoopIfHaltsOnItself, which leads to a program that cannot exist.
>> >The fact that you can decompile
>> >my method any make one instance of it no longer function does
>> >not in any way refute the general case.
>> > You would have to make
>> >every possible instance of my WillHalt() simultaneously not function
>> >in order to correctly refute my proof.
>>
>> Why would I have to do that?
>
>If there exists a single example of my unmodified program, then this creates
>the single counter-example required to refute:
>{No program can ever be written to determine whether any arbitrary program will halt}
>There would be one unmodified program that correctly refutes this statement, even if
>every other copy is modified.
What will that unmodified program return if you give it the program
LoopIfHaltsOnItself with the input LoopIfHaltsOnItself?
Marc Goodman
>>If (B) is true, then you have proven it may be possible to construct
>>a machine more powerful than a turing machine which can always
>>tell if a turing machine will halt/loop/or unknown. But, this
>>is tautological, because it's always possible to posit a class
>>of machines that is more powerful than another class of machines,
>
>
> http://home.att.net/~olcott/halting/index.html#objection02
> Neither the Analyzer nor the Analyzed are limited to Turing Machines
Great. Because the Halting problem only applies to Turing Machines,
and if neither your analyzer nor your Analyzed programs are limited
to Turing Machines, then you haven't proved anything about Turing
Machines. Case closed, you haven't disproven anything about Turing
Machines by your own admission.
Marc Goodman
>> If (B) is true, then you have proven it may be possible to
>> construct a machine more powerful than a turing machine which can
>> always tell if a turing machine will halt/loop/or unknown. But,
>> this is tautological, because it's always possible to posit a class
>> of machines that is more powerful than another class of machines,
>
>
> http://home.att.net/~olcott/halting/index.html#objection02 Neither
> the Analyzer nor the Analyzed are limited to Turing Machines
The contents of the link quoted above:
> (2) But the original LoopIfHalts() can still be constructed if we
> modify a copy of your WillHalt() so that it again returns the result
> back to LoopIfHalts().
>
> The possibility of creating one or more instances of WillHalt() that
> permit LoopIfHalts() to function does not refute this method. In
> other words defeating the security in less than every possible case
> does not prove that this method does not work. One single case where
> the security is not circumvented proves that the idea still works.
The crux of your argument is "One single case ... proves that the idea
still works." Only if the case consists of a TURING MACHINE that
implements LoopIfHalts. But, we've just proven that LoopIfHalts is
NOT a Turing Machine. Therefore, one single case DOES NOT prove
the idea still works. So, point 2 is bogus.
Peter Olcott
> | the string it outside of the domain. It must be a
> | syntactically correct program. (If it isn't then it won't
> | compile) It does not have to be semantically correct (there
> | can be bugs in it).
>
> OK, so I should rephrase that to be:
> 1. "WillHaltPO(M,w) can always determine whether any
> arbitrary, syntactically correct program, defined
> by M, will halt when presented with input w.
> This will be the case even if M includes the code
> of WillHaltPO(M,w)."
>
> Please confirm this is more acceptable.
I don't use M and w, these are too cryptic, but, the meaning
is the same. This also assumes that the security has not been
breached.
> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> [regarding 2.]
> | > So I would be right in thinking that if WillHaltPO(M.w)
> | > were to be running in a computer in which no other
> | > program whatsoever is running, it will work. To clarify
> | > what I mean by running 'alone', I include within
> | > WillHaltPO all code necessary to access its input and
> | > make its output, and no other.
> |
> | I am not sure what you mean here. It is generally difficult
> | to run a program without an operating system.
>
> Sorry, I'll try to explain.
>
> I wished to preempt any potential objection (now Frequent Objection
> 2) based on use of a second instance of the WillHalt process running
> in the same machine, or indeed for another instance in another,
> communicating, machine.
>
> Your refutation, as I understand it, does not depend on WillHalt
> running in a computer with an operating system. If so, it would be a
> good idea to clarify this.
Yes, an operating system is not required.
> | > Please also confirm tha WillHaltPO will not be prevented
> | > from working by running it in isolation.
> |
> | If no other programs are running, then there are no other
> | programs that have access to its results. This is a subtle
> | point though. The actual case of the Halting Problem is a
> | hypothetical what if, based on the static (ASCII text)
> | representation of a program.
>
> 'Static representation' - exactly so. Then we get no
> misunderstandings based on assuming multiple copies of WillHalt are
> being run.
In the most secure form it would be void WillHalt() running in
isolation from ROM. Some ROM OS components could also
be included as long as they are verified as 100% secure. In other
words they can't possibly permit by passing the defined security.
> | There are two significant points here:
> | (1) What if void WillHalt() is run and its security has
> | been circumvented?
> | Then it is possible for another program to makes its result
> | undecidable.
>
> So we prevent that.
>
> | (2) What if void WillHalt() is run and its security can not
> | possibly be circumvented in at least one instance for the
> | set of all programs?
>
> So we ensure that.
>
> | Then the Halting Problem has been refuted.
>
> I think the the original proof will still be valid for the original,
> limited, set of programs. That set does not, of course, include a
> successful WillHaltPO(M,w).
The original proof concluded:
{No program can ever be written to determine whether any arbitrary program will halt}
I provided a counter-example refuting this conclusion, therefore the original proof is refuted.
> | Even if this requires creating a very special hardware /
> | software system, that only processes Halting Problems, and
> | nothing else. Even if every piece of Software in the system
> | it burned directly into ROM chips to prevent its
> | modification. One single instance where access to the
> | result of WillHalt() is made impossible to all other
> | programs,
>
> There should be no objection to defining WillHaltOP(M,w) in that way,
> especially if it helps to define the the program in a watertight way.
>
> | creates the single valid counter-example
> | disproving:
> |
> | {No program can ever be written to determine whether any
> | arbitrary program will halt}
>
> There's a bit more to do before creation such as writing the code.
All that is moot. The proof that it can't possibly be done was wrong.
That Is all that my proof needs to show. I have proved that the
Halting Problem is not a problem. There are very great difficulties
ahead in actually constructing a real working WillHalt(), yet now
it is no longer proven to be impossible.
> Being pedantic, I would have put it more like:
> It defines one environment (of possibly more than one) which is seen
> to be necessary for the creation of a counter-example ... ('the
> Single' would be inappropriate because a given functionality can be
> implemented in different ways.)
One was is what is required. One single counter-example refutes the conclusion of the proof.
{No program can ever be written to determine whether any arbitrary program will halt}
>
> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> [regarding 3.]
>
> | > I believe you just confirmed that WillHaltPO(M,w) is a
> | > deterministic program which always returns the same
> | > result when presented with a given input pair of M and w,
> | > subject to the security condition which I restated as
> | > '2.'
> |
> | Yes.
> | (1) Same Program
> | (2) Same Input
> | (3) Same Security
> | Yields Same Results.
> |
> | Change any one of the above three, and different results are
> possible.
>
> That's clear so, (subject to the conditions discussed
> under 1. & 2., we have:
No, you can't leave (3) out. An execution trace where only
(3) is changed derives different results.
> 3. "WillHaltPO(M,w), is deterministic and will always
> return the same result when presented with a given input
> pair of M and w."
>
> ~~~~~~~~~~~~~~~~~~~~~~~~
> Please could you confirm my understanding under '1.'
I don't know which '1.' you are referring to. In what you
quoted of what I said (1)(2) and (3) are all required or
different results are possible. If only (3) is changed then
the execution trace derives different results.
> ~~~~~~~~~~~~~~~~~~~~~~~~
> If so, I believe we have arrived at a more robust and idiot-proof
> definition of your proposal for WillHalt.
>
> I would then like to work at formalising the rest of your refutation.
>
> This would take the traditional form:
>
> Given [WillHalt defined as in 1., 2., 3. plus other
> givens if found necessary during formalisation]
> To prove [A program can be written to determine whether
> any arbitrary program will halt]
> Method [formalisation of your X, Y, & Z and your logic]
> Conclusion [...]
> QED
>
> --
> )>==ss$$%PARR(º> Parr
>
>
> To prove [A program can be written to determine whether
> any arbitrary program will halt]
The proof can not conclude a statement quite as strong as this.
The most that my reasoning shows is that the original proof that
this is impossible is incorrect. It could possibly still be impossible
for other reasons besides the original proof. My estimate is that
it is possible.
Kenneth Doyle
> No. as long as a single unmodified copy of the my original program
> exists then this single copy still represents the required single
> counter-example to disprove the statement:
> No program can ever be written to determine whether any arbitrary
> program will halt
>
Your original program? You mean the one that pretends that the two letters
'Y' and 'N' are complete programs? You just said, in a recent posting,
that the input must be a program's code. You said that if the input string
was an english poem, then it wouldn't count. Or are you talking about your
other original program?
--
CodeCutter - good, fast and cheap; pick two.
Peter Olcott
"Kenneth Doyle" <nob...@notmail.com> wrote in message news:Xns952B8AF6F38FC...@61.9.191.5...
> "Peter Olcott" <olc...@worldnet.att.net> wrote in
> news:UHwKc.277072$Gx4....@bgtnsc04-news.ops.worldnet.att.net:
>
> > No. as long as a single unmodified copy of the my original program
> > exists then this single copy still represents the required single
> > counter-example to disprove the statement:
> > No program can ever be written to determine whether any arbitrary
> > program will halt
> >
>
> Your original program? You mean the one that pretends that the two letters
> 'Y' and 'N' are complete programs? You just said, in a recent posting,
No these are the two sets of programs that I am talking about now.
http://home.att.net/~olcott/halting/example.html
I haven't been talking about that other program for more than a week.
Read this whole link, and you will see what I mean.
Will Twentyman
> "Peter Olcott" <olc...@att.net> wrote in
> news:s1FJc.260689$Gx4.2...@bgtnsc04-news.ops.worldnet.att.ne
> t:
>
>
>>>It would be nice if they mentioned the restriction that
>>>the programming language needs to be Turing-Complete for
>>>the problem to apply.
>>>
>>>--
>>>Will Twentyman
>>>email: wtwentyman at copper dot net
>>
>>If one program could correctly determine if every other
>>program halts, I am sure that your specific type of program
>>would be included in the universal set of all programs,
>>don't you think?
>
>
>
> So according to you, you've proved that it's possible for a
> program to determine if a non-Turing-complete program halts?
Well, if the language is equivalent to primitive recursive functions,
it's pretty easy.
--
Will Twentyman
email: wtwentyman at copper dot net
Will Twentyman
>>It would be nice if they mentioned the restriction that the programming
>>language needs to be Turing-Complete for the problem to apply.
>>
>
> If one program could correctly determine if every other program
> halts, I am sure that your specific type of program would be
> included in the universal set of all programs, don't you think?
This is where getting a little more precise matters. Perhaps you
believe you have found a programming language that is equivalent to
oracle machines. In that case, you can find WillHalt(), but it's not
going to be any language I know of. What can or cannot be done depends
on context.
Will Twentyman
>>>Basic Structure of the Original Proof:
>>>Y makes X Impossible.
>>>
>>>Basic Structure of my refutation:
>>>Z makes Y impossible.
>>
>>Stated another way: if Y is true, X is false. But, if Z is true, Y is
>>false.
>>
>>Problem1, you have not shown that Z is tautologically true.
>>Problem2, Z true does not imply X is true.
>>--
>>Will Twentyman
>>email: wtwentyman at copper dot net
>
>
> Great, you are two for two on this one.
> Here is my counter
>
> If Z is true then the proof that X is impossible is false.
> I am not shooting for provein that X is true.
>
> Z entails not Y has been shown.
>
> No one has yet been able to show that Z is not true.
The original construction has Z false.
> I don't think that it will be very long before either
> someone finds a way to disable Z, or Z is known to
> be tautologically true.
Will Twentyman
> "No Way" <N...@real.com> wrote in message news:gbakf01kisichoj39...@4ax.com...
>
>>On Sat, 17 Jul 2004 18:29:33 GMT, "Peter Olcott"
>><olc...@worldnet.att.net> wrote:
>>
>>
>>>http://home.att.net/~olcott/halting/index.html#objection02
>>
>>It says: "The possibility of creating one or more instances of
>>WillHalt() that permit LoopIfHalts() to function does not refute this
>>method."
>>
>>But it does. Your method is founded on the idea that LoopIfHalts
>>cannot be constructed. As soon as it is shown that that is possible,
>>your method breaks down.
>
>
> No. as long as a single unmodified copy of the my original program exists
> then this single copy still represents the required single counter-example to
> disprove the statement:
> No program can ever be written to determine whether any arbitrary program will halt
This is not correct. This is analogous to claiming: "1+1 is not equal
to any natural number because I have found that 1+1 does not equal 3!"
If you truely want to disprove the the non-existences of WillHalt(),
just produce the code. That would be a counter-example, not all the
stuff you've been saying.
>>"One single case where the security is not circumvented proves that
>>the idea still works."
>
> Unless you can make my security impossible in all cases, you have
> not refuted my position. Even a single case would form the required
> single counter-example.
How about this. Add a user who reads the result of ModifiedWillHalt()
and types it in as input for LoopIfHalts(). BTW, your security is
meaningless since we are assumed to have access to all source code.
>>>http://home.att.net/~olcott/halting/example.html
>>>That is not true examine this page closely, and see for yourself.
>>
>>First of all, why does the WillHalt function (in the 'original')
>>contain an 'unknown' option? That WillHalt should be like this:
>
>
> Because this more clearly represents that actual facts. Most
> people assume that if a statement is not true, then it must be
> false. This assumption is incorrect.
Please clarify this statement.
What other possibilities are there, when a statement is normally defined
to be a claim that is either true or false but not both?
>>>>Which is rather interesting, because Turing Machines don't use
>>>>functions at all. If you think your situation is equivalent to the TM
>>>>situation, it must be possible to avoid functions.
>>>
>>>http://home.att.net/~olcott/halting/index.html#objection01
>>>See this link to see why any mention of Turing Machines
>>>is made moot.
>>
>>You just saying that doesn't make it true. If your 'proof' is a way to
>>show that the conclusion of 'the halting problem' is incorrect in
>>general, it should also be able to be applied to Turing Machines.
>
>
> There are two programs in the Halting Problem:
> (1) The Analyzer
> (2) The Analyzed
> The Analyzer is not limited to a Turing Machine. The Analyzed
> can include a Turing Machine. (I just updated my website with this).
Actually, in the original treatment they were both limited to Turing
Machines. When discussing the Halting Problem both are assumed to be
Turing Machines or something equivalent (neither more nor less powerful)
to Turing Machines.
>>>If it is a given that I can make access to the results of WillHalt()
>>>impossible for any specific program to access, then I have
>>>disproved the Halting Problem.
>>
>>No, you will have changed the problem to something else by adding a
>>rule (No program is allowed to exist that disproves that WillHalt can
>>exist).
>
> It is not merely a rule, if I can perfectly enforce it. It was merely
> a rule that other programs would be free to disobey, then I would
> have proved nothing. Since I have provided a set of ways to make
> access to the result of WillHalt() impossible, I have thus disproved
> the original Halting Problem.
You cannot perfectly enforce anything if you give us the source code.
>
>
>>>The fact that you can decompile
>>>my method any make one instance of it no longer function does
>>>not in any way refute the general case.
>>>You would have to make
>>>every possible instance of my WillHalt() simultaneously not function
>>>in order to correctly refute my proof.
>>
>>Why would I have to do that?
>
>
> If there exists a single example of my unmodified program, then this creates
> the single counter-example required to refute:
> {No program can ever be written to determine whether any arbitrary program will halt}
> There would be one unmodified program that correctly refutes this statement, even if
> every other copy is modified.
Give us the sourcecode to your WillHalt(), and we will construct the rest.
>parr(*>
| > OK, so I should rephrase that to be:
| > 1. "WillHaltPO(M,w) can always determine whether any
| > arbitrary, syntactically correct program, defined
| > by M, will halt when presented with input w.
| > This will be the case even if M includes the code
| > of WillHaltPO(M,w)."
| >
| > Please confirm this is more acceptable.
|
| I don't use M and w, these are too cryptic
The reason I used that form was because, in your refutation in:
http://home.att.net/~olcott/halting/index.html
you quote the page:
http://www.netaxs.com/people/nerp/automata/halting2.html
where the form WillHalt(M,w) was used in a formal proof.
Now you object to use of that form because it is 'too cryptic'.
What you really mean is that you do not understand that which you
quoted.
As you have been making spurious claims that you have disproved
established proofs in mathematics and computing theory for 3 years
now, I not only declare you to be unable to understand these matters,
but a troll to boot. The proof is simple, 'I say so therefore you
must be'.
(Mutter, mutter, I should have realised from your persistent deletion
of identification of previous message information. I should have
checked your track record. I should have realised that anyone who
posts to sci.logic who used that ancient ploy of removing one block
removes all blocks is a charlatan. I should have realised that
anyone who seems at home with certain advanced concepts and stumbles
over less advanced ones is playing games.)
Nice try, though. I reckon I'll use that 'security' approach one
day.
--
)>==ss$$%PARR(º> Parr
G. Frege
<Kurl...@tenretnitb.moc> wrote:
>>
>> I don't use M and w, these are too cryptic
>>
Uh right, but only in Olcott world.
>
> The reason I used that form was because, in [...]
> http://home.att.net/~olcott/halting/index.html
> you quote the page
> http://www.netaxs.com/people/nerp/automata/halting2.html
> where the form WillHalt(M,w) was used in a formal proof.
>
> Now you object to use of that form because it is 'too cryptic'.
>
> What you really mean is that you do not understand that which you
> quoted.
>
Seems rather obvious. He still likes to talk about things he does not
understand.
>
> As you have been making spurious claims that you have disproved
> established proofs in mathematics and computing theory for 3 years
> now [...]
>
Oh my god!!! :-o
F.
George Greene
: As you have been making spurious claims that you have disproved
: established proofs in mathematics and computing theory for 3 years
: now,
In what fora? Where can I find that?
I had never seen him on sci.logic before.
Kevin Stern
> > But see, that's the sad thing, Peter. People have put up and put up.
> > Your errors have been corrected and the flaws in your arguments have
> > been picked apart for you in excruciating detail again and again. So
> > while I could try to explain to you why your assertion above -- that the
> > original proof of the unsolvability of the Halting Problem simply yields
> > the completely uninteresting result that a particular *way* of trying to
> > code the Halt function fails -- is grossly mistaken; I could try to find
> > yet another way to explain the basics of computability to you in a way
> > that would enable you to see why you are wrong. But I and others have
> > already tried to do that, many times, and in many ways, but you seem
> > strangely unteachable. I sincerely hope the light comes on for you
> > someday.
> >
> > Chris Menzel
> >
> Yet again, ad infinitum, another statement posing as
> a refutation that again fails to find any errors in what
> I have said.
Hi folks,
This is a good example of the nonstandard logic system that Peter is
operating within. Chris' response above was most certainly not
'posing as a refutation' -there is no substring of his post that
would, interpreted in the standard way, serve as a refutation;
rather, Chris' post seems to be an account of previous refutations.
It would seem that it is impossible to make any progress in this
matter (since it has been going on for months), and the post above
just struck me as an illustrative example of the completely different
logic systems most of us and Peter operate within.
Kevin Stern
{
while (TRUE) // loop forever
;
else
return; // FALSE or UNKNOWN
}
This code has nothing to do with the halting problem. If you notice:
LoopIfHalts(LoopIfHalts, LoopIfHalts) calls WillHalt(LoopIfHalts,
LoopIfHalts) which, I assume, tests whether LoopIfHalts(LoopIfHalts)
halts. But this is the one parameter version of LoopIfHalts (a
completely different program ... you have the two parameter version
above, which will pose no problems whatsoever (either that or you'll
get a syntax error because you're only providing one parameter for a
two parametered function).
This may help: It is not the Halt portion of the halting problem that
causes problems, it's the NoHalt portion. Halt is recursively
enumerable ... we can confirm that a program halts within a finite
amount of time - we cannot decide which programs fail to halt within a
finite amount of time, though.
Let's say that we can ... NoHalt(x, y) is the program that we want.
Well then what of D(x) = return NoHalt(x, x)?
This is the anti-diagonal of the following enumeration of all Turing
Machines:
tm_1 tm_2 tm_3 [...]
tm_1 1 0 1 [...]
tm_2 0 0 1 [...]
tm_3 1 1 0 [...]
[...]
where row_x col_y = 1 if tm_x halts on input 'tm_y' and 0 otherwise.
so, specifically, there can be no row that outputs the correct
sequence of 1's and 0's and, interestingly, the conclusion is that no
row represents D - D is not a TM.
Kevin
"Peter Olcott" <olc...@worldnet.att.net> wrote in message news:<xCOKc.111569$OB3....@bgtnsc05-news.ops.worldnet.att.net>...
G. Frege
>
> the post above just struck me as an illustrative example of the
> completely different logic systems most of us and Peter operate
> within.
>
The two terms "reasonable" ("intelligent", "judicious", "rational",
"sane", "sensible", "sound") vs. "unreasonable" ("illogical",
"insensate", "insentient", "irrational") comes to mind.
"Nonstandard logic system", indeed.
F.
Daryl McCullough
>
>">parr\(*>" <Kurl...@tenretnitb.moc> writes:
> : As you have been making spurious claims that you have disproved
> : established proofs in mathematics and computing theory for 3 years
> : now,
>
>In what fora? Where can I find that?
>I had never seen him on sci.logic before.
Peter posted the same nonsense about Godel's theorem back in 2001,
in the newsgroup comp.sys.apple2
Daryl McCullough
>It would seem that it is impossible to make any progress in this
>matter (since it has been going on for months)
*Years*, actually. Peter first posted about Godel's theorem back
in 2001
(Assuming that this was the same Peter Olcott)
David Bandel
> "Peter Olcott" <olc...@att.net> wrote [etc.]
>
> Since I am deeply impressed by the mathematical maturity of a
> contributor to sci.logic and comp.theory, who shall remain nameless, I
> have decided to do a little number theory (which is not really my area,
> but...)
>
> Mathematicians generally claim that there do not exist even prime
> numbers greater than 2. However, I have found a FLAW in their so-called
> proof. Their "proof" goes as follows:
>
> Let n be an even integer where n > 2. Since n is even, n must be of the
> form 2k for some k, where k > 2. But this means that n has a nontrivial
> factor and therefore cannot be prime.
>
> But assume that we do not allow factorization of composite integers! We
> distinguish between:
>
> - Public factors: An integer f is a public factor of n, if f is known
> to be a factor of n
>
> - Secret factors: An integer f is a secret factor of n, if f is a
> factor of n but there is no way of determining if f is a factor (and
> division does not count - remember, we are assuming that factorization
> is illegal!!)
>
> Now the proof breaks down, since there can only be secret factors. We
> can no longer be sure that 2 is a factor of an even number, as
> factorization is assumed to be impossible! Thus it is very likely that
> some even numbers are primes.
>
> In fact, I think it may now well be the case that there are infinitely
> many even primes. I am even fairly sure that they can be randomly
> generated (by a secret prime number generator).
>
> Hans
another god damn idiot
Kent Paul Dolan
> Any idiot can take on the role of a mere naysayer.
> It sure look like you cherish that role.
Peter, you are not being ridiculed (by me and many
others) because we are all terrible people. You are
being ridiculed because your claims are ridiculous.
When you stop treating computer theory proofs as a
branch of politics, and start treating them as a
branch of mathematics, you might, just might, be on
the path back from a fate of lifelong kookdoom.
HTH
xanthian.
--
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG
Marc Goodman
> Yet it is still pretty hard. The difference is that a TM
> is about the simplest possible form of automata.
No, a finite state automata is about the simplest possible form of
automata. Turing Machines are actually as powerful as the most
powerful know form of computation. But feel free to just make
stuff up as you please.
Martin Shobe
<xant...@well.com> wrote:
>
>Give it up, Peter, you are an ignorant person trying
>to overturn the findings of well-informed people,
>and you don't have a prayer of doing so while you
>cherish your ignorance so highly. If you don't care
>to learn some computer theory before you try to
>revolutionize the field of computer theory, then
>you'd better be looking for that auto mechanic job
>that is more in your skill range, instead. The field
>of computer science has nothing to offer someone as
>lazy as you are proving yourself to be.
I, for one, wouldn't want him to work on my car. He would probably
replace the brakes with an oil filter, and then try to tell me that it
was obvious that it should be that way.
Martin
Kent Paul Dolan
> In any case it sure is not any form of valid refutation.
There is no need for me to refute your pretense at a proof;
more than sufficient experienced people have done that. My
experience is in ridiculing kooks to make them aware how
silly they look so that they will depart.
> Any idiot can take on the role of a mere naysayer.
I'm pretty sure that the "any idiot" role is "any idiot
can challenge a well founded theorum will ill founded
arguments". That would be your role in this macabre
entertainment, where you are much like the geek in the
circus, biting heads off of chickens to prove how mindless
you are. People laugh at such behavior, but it isn't a laugh
filled with kindness. It is a laugh of relief at not being
the geek.
Kent Paul Dolan
wrote:
> ">parr\(*>" <Kurl...@tenretnitb.moc> writes:
>> As you have been making spurious claims that you
>> have disproved established proofs in mathematics
>> and computing theory for 3 years now,
> In what fora? Where can I find that?
> I had never seen him on sci.logic before.
This is the usual way to ask that question:
http://groups.google.com/groups?as_uauthors=peter.olcott&as_scoring=d&num=100
In Peter's case, though, it produces a rather
strange result; Google claims that his postings are
so repetititive of themselves, that though he has
posted 3,500 articles over time, only 269 of them
are sufficiently different to be displayed as
independent news articles. Producing a result like
that requires an astonishingly mechanical rigidity
of thought.
Results 201 - 269 of about 3,500 for author:peter.olcott
This seems to be the earliest example googling finds
without extra effort, and you'll notice his thinking
processes was precisely as damaged then as it is
now. In this article, he is debunking Goedel's proof
of the incompleteness of mathematics, another proof
that any informed student can easily (well, fairly
easily) understand. Laury has it correct -- Peter is
beyond redemption. He is so fully mired in the kook
thinking process, he has no chance of recovery. The
only way to help him is with your silence. If he is
profoundly ignored, perhaps he will tire of his
current brand of insanity, and seek out a different
one.
http://groups.google.com/groups?selm=3A862728.852F33FD%40uswest.net&output=gplain
It's of interest that Peter's kook path has taken
him through claims to out-expert the experts in at
least two independent scientific fields, in neither
of which he is capable of carrying on a conversation
without babbling. This goes a bit further than James
Harris, who, while claiming (incorrectly) to have
solved several of the great problems of math, at
least stuck to math and didn't also start making
claims in, say, archeology.
In both cases, I think the main motivation is the
wish for glory without sweat.
HTH
Peter Olcott
"Kent Paul Dolan" <xant...@well.com> wrote in message news:052f4ea3d0180d3e8ac...@mygate.mailgate.org...
> "Peter Olcott" <olc...@worldnet.att.net> wrote:
>
> > Any idiot can take on the role of a mere naysayer.
> > It sure look like you cherish that role.
>
> Peter, you are not being ridiculed (by me and many
> others) because we are all terrible people. You are
> being ridiculed because your claims are ridiculous.
If they were actually what you claim, then there should
be at least seventeen valid refutations. About all that I
am getting is the Ad Hominem and/or Ad Vericundiam
fallacies from most of you. I have not received a single
valid refutation.
Nothing at all that you said has been even in the ballpark
of as much as an incorrect refutation.
Mitch Harris
> About all that I
> am getting is the Ad Hominem and/or Ad Vericundiam
> fallacies from most of you. I have not received a single
> valid refutation.
>
> Nothing at all that you said has been even in the ballpark
> of as much as an incorrect refutation.
http://www.cuyamaca.net/bruce.thompson/Fallacies/rugged.asp
--
Mitch Harris
(remove q to reply)