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.

(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.

Peter Olcott 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:
> (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

Once again I am resisting to answer, but fail...

On Tue, 13 Jul 2004 23:31:58 GMT, "Peter Olcott" <olcott@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. "

"Peter Olcott" <olcott@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.

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

"Peter Olcott" <olcott@att.net> wrote in message
news:Oh_Ic.91468$OB3.15698@bgtnsc05-news.ops.worldnet.att.net...
| 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.
|
[...]

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

> 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.

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.

> 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.

In comp.theory Peter Olcott <olcott@worldnet.att.net> wrote:
> 
>> 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.

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!
newstome@comcast.net

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:H1ZJc.102348$OB3.64898@bgtnsc05-news.ops.worldnet.att.net...
|
| > 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.

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

<newstome@comcast.net> wrote in message
news:dAZJc.95638$%_6.5722@attbi_s01...
| In comp.theory Peter Olcott <olcott@worldnet.att.net> wrote:
| > You say that you proved X.
| > I prove that you did not prove X.
|
| 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).

Patience.  This route was followed before.
--
)>==ss$$%PARR(�>   Parr

"Kent Paul Dolan" <xanthian@well.com> wrote in message
news:8fa7d179d429a1b010830abe23556d80.48257@mygate.mailgate.org...
| "Peter Olcott" <olcott@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

On Fri, 16 Jul 2004 22:46:22 GMT, "Peter Olcott"
<olcott@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?

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

En la afisho <2VYJc.102313$OB3.55899@bgtnsc05-news.ops.worldnet.att.net>
"Peter Olcott" <olcott@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

"Peter Olcott" <olcott@att.net> wrote in message
news:Oh_Ic.91468$OB3.15698@bgtnsc05-news.ops.worldnet.att.net...
| Most recently updated version of this informal proof will be posted
on this
[etc]

A further question:

Have you created a successful 'WillHalt(M,w)' function?
--
)>==ss$$%PARR(�>   Parr

> 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!
> newstome@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

> | 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.
>
> 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.
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

> >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.

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.

"Taneli Huuskonen" <huuskone@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.55899@bgtnsc05-news.ops.worldnet.att.net>
> "Peter Olcott" <olcott@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" <olcott@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

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:34eKc.271499$Gx4.47885@bgtnsc04-news.ops.worldnet.att.net...
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

"Hans H�ttel" <hans@cs.auc.dk> wrote in message
news:40f9a4a6$0$3077$ba624c82@nntp05.dk.telia.net...
[...]
| 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).

I don't see how this refutes Peter's refutation.
--
)>==doZEN(�>   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

> 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.

">parr(*>" <KurlyGina@tenretnitb.moc> wrote in message news:cdccp9$ldj$1@titan.btinternet.com...
> "Hans H�ttel" <hans@cs.auc.dk> wrote in message
> news:40f9a4a6$0$3077$ba624c82@nntp05.dk.telia.net...
> [...]
> | 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).
>
> I don't see how this refutes Peter's refutation.
> --
> )>==doZEN(�>   Parr
>

Finally the first word of actual support. Thanks.

Hans H�ttel  <hans@cs.auc.dk> wrote:
>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:

That's a coincidence. I've discovered a flaw in the 
standard proof that sqrt{2} is irrational. It's so easy to find
that I'm amazed nobody has previously made the observation.

All you have to do is write the proof out in pencil,
and then *rub out the last line*. The contradiction
clearly disappears, so we can no longer conclude that
sqrt{2} is irrational.

I'm currently working on extending this to a large
collection of other proofs which had been previously
assumed to be correct.

-- 
Rob.  http://www.mis.coventry.ac.uk/~mtx014/

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

En la afisho <nkeKc.271570$Gx4.42914@bgtnsc04-news.ops.worldnet.att.net>
"Peter Olcott" <olcott@worldnet.att.net> skribis:


>"Taneli Huuskonen" <huuskone@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
-----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

On Sat, 17 Jul 2004 18:29:33 GMT, "Peter Olcott"
<olcott@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.

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:VfjKc.273073$Gx4.228024@bgtnsc04-news.ops.worldnet.att.net...
|
| > 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

On Sat, 17 Jul 2004 18:29:33 +0000, Peter Olcott wrote:

>> >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.
> 
> 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.
> 
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.

> >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

> 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
> -----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

"No Way" <Not@real.com> wrote in message news:gbakf01kisichoj39repegcq4k9jcqqadc@4ax.com...
> On Sat, 17 Jul 2004 18:29:33 GMT, "Peter Olcott"
> <olcott@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.

> 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.

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.

> >> Explain to me why the decompile/recompile trick doesn't always work?
> >I just did.
>
> No, you didn't.
>

> 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).

> 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.

I refer to the code from:
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

Marc Goodman says...

[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

"Daryl McCullough" <daryl@atc-nycorp.com> wrote:

> Peter is incapable of following a logical argument.

He's also incapable of thinking about computation in
the domain of Turing machines, at all.

Thus his recent complaint that "its pretty hard to
run a program without an operating system".

Yet that's exactly what a Turing machine does.

That's exactly what a program to solve the halting
problem is expected to do, since the model of
computetion under which the halting problem solver
disproof is given is specifically the Turning
machine.

That's exactly what all of my computer programming
for the first two years of my life as a programmer
did, and everyone else's did then too, back before
operating systems even existed.

Peter is on a typicl Usenet kook's "search for glory
without exerting sufficient effort", and all he will
ever find with his current approach is ignominy,
instead.

xanthian.



-- 
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG

Daryl McCullough wrote:
> 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.

"Peter Olcott" <olcott@worldnet.att.net> writes:

 : > 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?


-- 
 --- 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

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:80xKc.277169$Gx4.136608@bgtnsc04-news.ops.worldnet.att.net...
| [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" <olcott@worldnet.att.net> wrote:

> Finally the first word of actual support. Thanks.

That wasn't a word of support, Peter. That was two
people both making fun of you by employing sarcasm,
just doing it in different ways.

You have insistently made yourself an object of
ridicule, and people, not to disappoint you, or make
all your efforts futile, are ridiculing you, with
many tools, including sarcasm.

Invincable ignorance, unfortunately, is as immune to
sarcasm as to any other attempts to slip new
information past its defenses. That's why it is
called "invincible", and has been since it was
characterized by Saint Augustine around 412 AD and
reaffirmed by Saint Thomas Aquinus in his _Summa
Theologica_ around 1260 or so.

"Invincible ignorance excuses from sin, we admit, in
that whereof one is invincibly ignorant, but it
confers no virtue, and is purely negative."
                                 -- Orestes Brownson

xanthian.



-- 
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:40FAAB27.4070402@comcast.net...
> I refer to the code from:
> 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,

http://home.att.net/~olcott/halting/index.html#objection02
Neither the Analyzer nor the Analyzed are limited to Turing 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
>

"Kent Paul Dolan" <xanthian@well.com> wrote in message news:b2cdd06a3be507691d2fb7bd71f25f2e.48257@mygate.mailgate.org...
> "Daryl McCullough" <daryl@atc-nycorp.com> wrote:
>
> > Peter is incapable of following a logical argument.
>
> He's also incapable of thinking about computation in
> the domain of Turing machines, at all.
>
> Thus his recent complaint that "its pretty hard to
> run a program without an operating system".
>
> Yet that's exactly what a Turing machine does.

Yet it is still pretty hard. The difference is that a TM
is about the simplest possible form of automata.

On Sun, 18 Jul 2004 15:29:56 GMT, "Peter Olcott"
<olcott@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?

Peter Olcott wrote:
>>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.

Peter Olcott wrote:
> 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.

Peter Olcott wrote:
>> 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.

> | 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.

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.

"Peter Olcott" <olcott@worldnet.att.net> wrote in
news:UHwKc.277072$Gx4.4006@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, 
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" <olcott@worldnet.att.net> wrote:

> Yet it is still pretty hard. The difference is
> that a TM is about the simplest possible form of
> automata.

How does a person with so little experience as you
have with computers and computing decide that he is
going to be the one to overturn the single best
checked proof in the field of computing theory?

There is nothing even remotely difficult about
executing a computer program without an operating
system.  At least hundreds of thousands, more likely
millions of home computer hobbiests toggled programs
in or punched them in with a hex keypad and ran them
on the earliest home computers, without an operating
system; it was never "hard", just "tedious".

From the middle of the second world war until
sometime in perhaps the middle 1960's, all computer
programs were run without operating systems,
because, again, there was no such thing as an
operating system.  Again, it wasn't "hard", just
time consuming.

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.

Your "proofs" that depend for their defense on the
fact that you've never bothered to explain clearly
what it is you are claiming as a program that solves
the halting problem, are simply shams, no proofs at
all, nor will all your repetitions of "read it
again", or patches to programs that don't do what
you have been claiming already to have proved them
to do, change that characterization in the
slightest.

xanthian.



-- 
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG

"Peter Olcott" <olcott@att.net> wrote [etc.]

The approach to doing maths outlined by a comp.theory luminary, who 
shall remain nameless, continues to be a source of awe and inspiration 
for me. See below.

Mathematicians have often claimed that there are infinitely many primes.

However, consider the following proof:

Let a and b be even natural numbers. Then for some m,n we have a = 2m 
and b = 2m. Clearly, the product ab = 4mk, so ab is also even. End of proof.

Clearly, the above is not a proof of the claim that there are infinitely 
many primes. Consequently, the statement must be false.

I now believe that there are in fact only finitely many primes. In fact, 
it may well be possible to find these finitely many primes using a 
random number generator.

Hans

On Mon, 19 Jul 2004 05:45:28 +0000 (UTC), "Kent Paul Dolan"
<xanthian@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

"Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns952B8AF6F38FCnobodynotmailcom@61.9.191.5...
> "Peter Olcott" <olcott@worldnet.att.net> wrote in
> news:UHwKc.277072$Gx4.4006@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.

> 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.

"Kent Paul Dolan" <xanthian@well.com> wrote in message news:1767aa51fb7d0dc090ec3df74ead206d.48257@mygate.mailgate.org...
> "Peter Olcott" <olcott@worldnet.att.net> wrote:
>
> > Yet it is still pretty hard. The difference is
> > that a TM is about the simplest possible form of
> > automata.
>
> How does a person with so little experience as you
> have with computers and computing decide that he is
> going to be the one to overturn the single best
> checked proof in the field of computing theory?

What is this ad verecundiam or ad hominem?
In any case it sure is not any form of valid refutation.
Any idiot can take on the role of a mere naysayer.
It sure look like you cherish that role.

"Peter Olcott" <olcott@worldnet.att.net> wrote:

> 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.

xanthian.



-- 
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG

Peter Olcott wrote:

> "No Way" <Not@real.com> wrote in message news:gbakf01kisichoj39repegcq4k9jcqqadc@4ax.com...
> 
>>On Sat, 17 Jul 2004 18:29:33 GMT, "Peter Olcott"
>><olcott@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.

-- 
Will Twentyman
email: wtwentyman at copper dot net

"Peter Olcott" <olcott@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.

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

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:MYGKc.110387$OB3.2183@bgtnsc05-news.ops.worldnet.att.net...
| > 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

void LoopIfHalts(string SourceCode, string InputData)
{
  if (WillHalt(SourceCode, InputData) == TRUE)
    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" <olcott@worldnet.att.net> wrote in message news:<xCOKc.111569$OB3.81647@bgtnsc05-news.ops.worldnet.att.net>...
> "Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns952B8AF6F38FCnobodynotmailcom@61.9.191.5...
> > "Peter Olcott" <olcott@worldnet.att.net> wrote in
> > news:UHwKc.277072$Gx4.4006@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.
> 
> > 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.

Hans H�ttel <hans@cs.auc.dk> wrote in message news:<40f9a4a6$0$3077$ba624c82@nntp05.dk.telia.net>...
> "Peter Olcott" <olcott@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

> 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'.

WillHalt(string SourceCode, string InputData) is far less 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'.

They why is it that no one has found a single valid refutation?

"Kent Paul Dolan" <xanthian@well.com> wrote in message news:052f4ea3d0180d3e8accfd568c3155cb.48257@mygate.mailgate.org...
> "Peter Olcott" <olcott@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.

Peter Olcott wrote:
>>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'.
> 
> 
> They why is it that no one has found a single valid refutation?

Turing says: It is impossible for a square to be round.
Olcott says: Here's a circle.  It's round.  Therefore Turing is wrong.
Everyone says: That's not a square, it's a circle.  Therefore you
    haven't proven that Turing was wrong.
Olcott says: You obviously haven't read my web page.  Here's the URL.
Everyone says: We read your web page, it's still not a square, it's a
    circle.
Olcott says: No one has found a single valid refutation for my
    theory.


You win, Peter.  But it's still a circle.

Peter Olcott wrote:
 > 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)

Peter Olcott wrote:

>>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'.
> 
> 
> WillHalt(string SourceCode, string InputData) is far less 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'.
> 
> 
> They why is it that no one has found a single valid refutation?

Why is it that you have ignored my refutation?

-- 
Will Twentyman
email: wtwentyman at copper dot net

">parr(*>" <KurlyGina@tenretnitb.moc> wrote in message news:cdh6kq$n7d$1@hercules.btinternet.com...
> "Peter Olcott" <olcott@worldnet.att.net> wrote in message
> news:MYGKc.110387$OB3.2183@bgtnsc05-news.ops.worldnet.att.net...
> | > 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.
Not at all. What I am saying from a professional programmer
perspective is that single letter names are bad programming.
They are not self-documenting.

Peter Olcott says...

>They why is it that no one has found a single valid refutation?

Peter, the reason you *believe* that no one has found a refutation
is because you are not competent to recognize a valid argument when
you see one. You have been given many valid refutations, and you
were no more able to understand them than my cat.

--
Daryl McCullough
Ithaca, NY

Daryl McCullough wrote:
> Peter Olcott says...
> 
>>They why is it that no one has found a single valid refutation?
> 
> Peter, the reason you *believe* that no one has found a refutation
> is because you are not competent to recognize a valid argument when
> you see one. You have been given many valid refutations, and you
> were no more able to understand them than my cat.

Cats can only count up to four.

-- 
Mitch Harris
(remove q to reply)

On Tue, 20 Jul 2004, Daryl McCullough wrote:
>
> Peter Olcott says...
> >They why is it that no one has found a single valid refutation?
>
> Peter, the reason you *believe* that no one has found a refutation
> is because you are not competent to recognize a valid argument when
> you see one. You have been given many valid refutations, and you
> were no more able to understand them than my cat.

  Is your cat hard to understand? :)

-Arthur

Peter Olcott wrote:

> ">parr(*>" <KurlyGina@tenretnitb.moc> wrote in message news:cdh6kq$n7d$1@hercules.btinternet.com...
> 
>>"Peter Olcott" <olcott@worldnet.att.net> wrote in message
>>news:MYGKc.110387$OB3.2183@bgtnsc05-news.ops.worldnet.att.net...
>>| > 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.
> 
> Not at all. What I am saying from a professional programmer
> perspective is that single letter names are bad programming.
> They are not self-documenting.

On the other hand, they are perfectly good mathematics.  It is worth 
noting that the Halting Problem is a math problem first, computer 
problem second.  A program may halt in an unreasonable amount of time. 
This is not a concern to someone worried about the theory, but a great 
concern to someone worried about the application.

-- 
Will Twentyman
email: wtwentyman at copper dot net

Arthur J. O'Dwyer says...
>
>
>On Tue, 20 Jul 2004, Daryl McCullough wrote:
>> You have been given many valid refutations, and you
>> were no more able to understand them than my cat.
>
>  Is your cat hard to understand? :)

Nobody understands my cat the way I do. (Isn't that right, Fafard?)

--
Daryl McCullough
Ithaca, NY

> >>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.

One programs is greater than no program, don't you agree?
Only one more  than none is required to refute this claim.

> 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(),

Whoops did you say that backwards?

> just produce the code.  That would be a counter-example, not all the
> stuff you've been saying.

Yeah right, like this is a reasonable requirement.

>
> >>"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.

You can make any assumption that is possible. You can not make
any assumption that is not possible. I am not going to bother responding
to the rest until we reach agreement on the prior. Do you understand
what a proof by counter-example is? If you do please elaborate, if you
do not, you won't be able to understand what I am saying.

NOTE Your responses above seemed to indicate that you are
not fully conversant with the concept of proof by 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.
>
> 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.
>
> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>

"Kevin Stern" <K-Stern@neiu.edu> wrote in message news:ca77e32d.0407191227.2715e440@posting.google.com...
> void LoopIfHalts(string SourceCode, string InputData)
> {
>   if (WillHalt(SourceCode, InputData) == TRUE)
>     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).

http://home.att.net/~olcott/halting/example.html
examine this and get back to me


> 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" <olcott@worldnet.att.net> wrote in message news:<xCOKc.111569$OB3.81647@bgtnsc05-news.ops.worldnet.att.net>...
> > "Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns952B8AF6F38FCnobodynotmailcom@61.9.191.5...
> > > "Peter Olcott" <olcott@worldnet.att.net> wrote in
> > > news:UHwKc.277072$Gx4.4006@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.
> >
> > > 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.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m41qjFik5t1U1@uni-berlin.de...
> Peter Olcott wrote:
>  > 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)
>

That's not a valid refutation either. Yes I am a
rugged individualist. All the conformists gave up
long ago, I guess that's why it was so easy.

> > They why is it that no one has found a single valid refutation?
>
> Why is it that you have ignored my refutation?
>
> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>
It was not valid, whether you understand why or not.
I will try very hard to make what I am saying clear
enough so that everyone here will understand it. I
am not the best writer, and that is part of the problem.

"Daryl McCullough" <daryl@atc-nycorp.com> wrote in message news:cdj3oq01tku@drn.newsguy.com...
> Peter Olcott says...
>
> >They why is it that no one has found a single valid refutation?
>
> Peter, the reason you *believe* that no one has found a refutation
> is because you are not competent to recognize a valid argument when
> you see one. You have been given many valid refutations, and you
> were no more able to understand them than my cat.
>
> --
> Daryl McCullough
> Ithaca, NY

Sorry, not true. Not only were most of the refutations not
valid, most were also provably false. I am not nearly as
good with words as I am with logic, that (and/or Groupthink)
is why most people have not yet fully understood what I
am saying.

"No Way" <Not@real.com> wrote in message news:m7cmf0d9mlrgfos2chc5j3o7prtvrq2rli@4ax.com...
> On Sun, 18 Jul 2004 15:29:56 GMT, "Peter Olcott"
> <olcott@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).

Boy oh boy you are good with that Petitio Principii!!!
Maybe I should quit even trying to explain any just point out
the errors in the refutations.


> >> 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.

Learn about proof by counter-example and get back to me.


> >> >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" <marc.goodman@comcast.net> wrote in message news:KMGKc.128008$XM6.95805@attbi_s53...
> Peter Olcott wrote:
> > 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.
>

I tend to be very exactly and precise in what I say. If I had
intended to say that Turing Machines are the simplest of all
possible automata, I would have phrased at as such. They
are very close to DFA's in their overall complexity.

I am the patent pending inventor of several finite automata.

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:40FB381A.8080302@comcast.net...
> Peter Olcott wrote:
> >>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,

That is a flatly false statement. You can't prove that it is true, and
I can prove that its false.

No program can ever be written to determine whether any arbitrary program will halt
http://www.nist.gov/dads/HTML/haltingProblem.html

> 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.
>

Peter Olcott wrote:
> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:40FB381A.8080302@comcast.net...
>>Great.  Because the Halting problem only applies to Turing Machines,

> That is a flatly false statement. You can't prove that it is true, and
> I can prove that its false.

http://mathworld.wolfram.com/HaltingProblem.html

Sorry Binkie, the NIST site uses the term "program" in an informal
sense.  Here's the description from MathWorld:



Halting Problem
	

The determination of whether a Turing machine will come to a halt given 
a particular input program. The halting problem is solvable for machines 
with less than four states. However, the four-state case is open, and 
the five-state case is almost certainly unsolvable due to the fact that 
it includes machines iterating Collatz-like congruential functions, and 
such specific problems are currently open. The problem of whether a 
general Turing machine halts is undecidable, as first proved by Turing 
(Wolfram 2002, pp. 1137-1138)


It would be pretty odd if Turing came up with a proof using Turing
Machines that wasn't about Turing Machines, wouldn't it?

Peter Olcott wrote:

>>>>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.
> 
> One programs is greater than no program, don't you agree?
> Only one more  than none is required to refute this claim.

You offer a function:

void POWillHalt(string function, string input)
{
  [do stuff to figure out if function(input) halts]
  cout << result;
}

I can change it to

bool StandardWillHalt(string function, string input)
{
  [do stuff to figure out if function(input) halts]
  return result;
}

If you can't offer the source code, you can't claim to have the 
solution.  If you can offer the source code, I can modify how it does 
the output so that we can construct the standard contradiction.  This 
should strongly suggest that your code didn't work as advertised.

This should not be a radical idea if you are a programmer.  Using cout 
(or whatever for your language of choice) to monitor variables in 
processing is hardly a new concept, yet all those lines tend to get 
commented out once you finish testing.  *How* you output your results is 
irrelevant to the processing of the results.  The contradiction lies in 
assuming it is possible to actually process whether a function will halt 
on a given input.  The method of output is irrelevant.

>>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(),
> 
> Whoops did you say that backwards?

Sorry, if you want to prove the existence of WillHalt().

>>just produce the code.  That would be a counter-example, not all the
>>stuff you've been saying.
> 
> Yeah right, like this is a reasonable requirement.

Considering there is a proof, and I have a method outlined to take 
whatever code you claim will work and produce the contradiction, yes.  I 
have a method of modification outlined.  You say it will not disprove 
your claims.  Since I've started following your arguments, you have yet 
to show how doing a copy/paste of your algorithm into a different 
function violates anything.

>>>>"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.
> 
> 
> You can make any assumption that is possible. You can not make
> any assumption that is not possible. I am not going to bother responding
> to the rest until we reach agreement on the prior. Do you understand
> what a proof by counter-example is? If you do please elaborate, if you
> do not, you won't be able to understand what I am saying.

Proof by contra-positive:  Assume that what you want to disprove is 
true.  Using that as the *only* assumption not included in the premises, 
carefully show that a contradictory situation arises.  Conclude that the 
added assumption was therefor false.

Example: the standard proof that the WillHalt() does not exist.

Proof by counter-example: provide a clear instance of a situation where 
all the premises are satisfied, yet the conclusion is violated.

Example: Claim: "There are no cats on Earth!"  Counter-example: My cat, 
Abby, who resides in South Carolina, United States, Earth.

> NOTE Your responses above seemed to indicate that you are
> not fully conversant with the concept of proof by counter-example.

There is a difference between showing that additional premises make a 
method of proof invalid and showing that the object described actually 
exists.  You have shown there is a way to make the standard proof 
invalid, but that does not make the conclusion invalid.  What I have 
provided above is the necessary patch to cross from your situation back 
to the standard proof.

-- 
Will Twentyman
email: wtwentyman at copper dot net

Peter Olcott wrote:

>>>They why is it that no one has found a single valid refutation?
>>
>>Why is it that you have ignored my refutation?
>>
>>
> 
> It was not valid, whether you understand why or not.
> I will try very hard to make what I am saying clear
> enough so that everyone here will understand it. I
> am not the best writer, and that is part of the problem.

No, I mean if you look at your original post in this thread, there is a 
reply by me, which you did not reply to.  It is available on google.

-- 
Will Twentyman
email: wtwentyman at copper dot net

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:0VjLc.133189$IQ4.103408@attbi_s02...
> Peter Olcott wrote:
> > "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:40FB381A.8080302@comcast.net...
> >>Great.  Because the Halting problem only applies to Turing Machines,
>
> > That is a flatly false statement. You can't prove that it is true, and
> > I can prove that its false.
>
> http://mathworld.wolfram.com/HaltingProblem.html
>
> Sorry Binkie, the NIST site uses the term "program" in an informal
> sense.  Here's the description from MathWorld:

So you are saying that a machine that can not be transformed into a
Turing Machine, yet can correctly determine whether or not any other
software system (including Turing Machines) halts, would not solve
the Halting Problem because it is not implemented as a Turing Machine?

I doubt if you can prove this one.


>
>
> Halting Problem
>
>
> The determination of whether a Turing machine will come to a halt given
> a particular input program. The halting problem is solvable for machines
> with less than four states. However, the four-state case is open, and
> the five-state case is almost certainly unsolvable due to the fact that
> it includes machines iterating Collatz-like congruential functions, and
> such specific problems are currently open. The problem of whether a
> general Turing machine halts is undecidable, as first proved by Turing
> (Wolfram 2002, pp. 1137-1138)
>
>
> It would be pretty odd if Turing came up with a proof using Turing
> Machines that wasn't about Turing Machines, wouldn't it?
>

"Will Twentyman" <wtwentyman@read.my.sig> wrote in message news:40fdceb5_3@newsfeed.slurp.net...
> Peter Olcott wrote:
>
> >>>>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.
> >
> > One programs is greater than no program, don't you agree?
> > Only one more  than none is required to refute this claim.
>
> You offer a function:
>
> void POWillHalt(string function, string input)
> {
>   [do stuff to figure out if function(input) halts]
>   cout << result;
> }


If I can provide any means to refute the statement below, I have refuted the HAlting Problem.
No program can ever be written to determine whether any arbitrary program will halt

It does not matter what you do with this solution, after the fact. It has already
been correctly refuted.



> I can change it to
>
> bool StandardWillHalt(string function, string input)
> {
>   [do stuff to figure out if function(input) halts]
>   return result;
> }
>
> If you can't offer the source code, you can't claim to have the
> solution.  If you can offer the source code, I can modify how it does
> the output so that we can construct the standard contradiction.  This
> should strongly suggest that your code didn't work as advertised.
>
> This should not be a radical idea if you are a programmer.  Using cout
> (or whatever for your language of choice) to monitor variables in
> processing is hardly a new concept, yet all those lines tend to get
> commented out once you finish testing.  *How* you output your results is
> irrelevant to the processing of the results.  The contradiction lies in
> assuming it is possible to actually process whether a function will halt
> on a given input.  The method of output is irrelevant.
>
> >>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(),
> >
> > Whoops did you say that backwards?
>
> Sorry, if you want to prove the existence of WillHalt().
>
> >>just produce the code.  That would be a counter-example, not all the
> >>stuff you've been saying.
> >
> > Yeah right, like this is a reasonable requirement.
>
> Considering there is a proof, and I have a method outlined to take
> whatever code you claim will work and produce the contradiction, yes.  I
> have a method of modification outlined.  You say it will not disprove
> your claims.  Since I've started following your arguments, you have yet
> to show how doing a copy/paste of your algorithm into a different
> function violates anything.
>
> >>>>"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.
> >
> >
> > You can make any assumption that is possible. You can not make
> > any assumption that is not possible. I am not going to bother responding
> > to the rest until we reach agreement on the prior. Do you understand
> > what a proof by counter-example is? If you do please elaborate, if you
> > do not, you won't be able to understand what I am saying.
>
> Proof by contra-positive:  Assume that what you want to disprove is
> true.  Using that as the *only* assumption not included in the premises,
> carefully show that a contradictory situation arises.  Conclude that the
> added assumption was therefor false.
>
> Example: the standard proof that the WillHalt() does not exist.
>
> Proof by counter-example: provide a clear instance of a situation where
> all the premises are satisfied, yet the conclusion is violated.
>
> Example: Claim: "There are no cats on Earth!"  Counter-example: My cat,
> Abby, who resides in South Carolina, United States, Earth.
>
> > NOTE Your responses above seemed to indicate that you are
> > not fully conversant with the concept of proof by counter-example.
>
> There is a difference between showing that additional premises make a
> method of proof invalid and showing that the object described actually
> exists.  You have shown there is a way to make the standard proof
> invalid, but that does not make the conclusion invalid.  What I have
> provided above is the necessary patch to cross from your situation back
> to the standard proof.
>
> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>

> Proof by contra-positive:  Assume that what you want to disprove is
> true.  Using that as the *only* assumption not included in the premises,
> carefully show that a contradictory situation arises.  Conclude that the
> added assumption was therefor false.
>
> Example: the standard proof that the WillHalt() does not exist.
>
> Proof by counter-example: provide a clear instance of a situation where
> all the premises are satisfied, yet the conclusion is violated.
>
> Example: Claim: "There are no cats on Earth!"  Counter-example: My cat,
> Abby, who resides in South Carolina, United States, Earth.


No Solution to the halting Problem can possibly exist,
It can't exist because Y makes it impossible.
Wait Z can eliminate Y. Once Y is gone, then
the proof by contradiction loses its contradiction.





>
> > NOTE Your responses above seemed to indicate that you are
> > not fully conversant with the concept of proof by counter-example.
>
> There is a difference between showing that additional premises make a
> method of proof invalid and showing that the object described actually
> exists.  You have shown there is a way to make the standard proof
> invalid, but that does not make the conclusion invalid.  What I have
> provided above is the necessary patch to cross from your situation back
> to the standard proof.
>
> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>

"Will Twentyman" <wtwentyman@read.my.sig> wrote in message news:40fdcf26$1_3@newsfeed.slurp.net...
> Peter Olcott wrote:
>
> >>>They why is it that no one has found a single valid refutation?
> >>
> >>Why is it that you have ignored my refutation?
> >>
> >>
> >
> > It was not valid, whether you understand why or not.
> > I will try very hard to make what I am saying clear
> > enough so that everyone here will understand it. I
> > am not the best writer, and that is part of the problem.
>
> No, I mean if you look at your original post in this thread, there is a
> reply by me, which you did not reply to.  It is available on google.
>
> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>
None of them were valid, Until this very evening I carefully studied
everyone of them. Some that were far too rude, I did not respond to.
I read them anyway. Its like this no refutation was valid, therefore
your refutation was not valid.

Peter Olcott wrote:
> So you are saying that a machine that can not be transformed into a
> Turing Machine, yet can correctly determine whether or not any other
> software system (including Turing Machines) halts, would not solve
> the Halting Problem because it is not implemented as a Turing Machine?

Exactly so.  If it requires a model of computation more powerful
than a regular Turing Machine, it says nothing at all about the
strengths or limitations of a Turing Machine, and is therefore
irrelevant to a discussion of the Halting Problem.

In comp.theory Peter Olcott <olcott@worldnet.att.net> wrote:

: So you are saying that a machine that can not be transformed into a
: Turing Machine, yet can correctly determine whether or not any other
: software system (including Turing Machines) halts, would not solve
: the Halting Problem because it is not implemented as a Turing Machine?

The important fact is not that it is not implemented as a Turing Machine,
but that it *cannot be implemented* as a Turing Machine.   Your last
phrase should be
	'because it cannot be implemeted as a Turing Machine.'

Stephen

dwb1729@yahoo.com (David Bandel) wrote in message news:<a88af92f.0407191446.13dab90d@posting.google.com>...
> Hans H�ttel <hans@cs.auc.dk> wrote in message news:<40f9a4a6$0$3077$ba624c82@nntp05.dk.telia.net>...
> > "Peter Olcott" <olcott@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

It's pretty obvious that this is satire.

'cid 'ooh

"Peter Olcott" <olcott@worldnet.att.net> wrote in 
news:EiiLc.292221$Gx4.63033@bgtnsc04-news.ops.worldnet.att.net:

> I
> am not the best writer, and that is part of the problem.
> 

But Peter, you are a expert in semantics; remember?  You understand your 
arguments with unmatchable clarity.  How can it possibly be that you aren't 
the most accurate and effective writer on the planet?


-- 
CodeCutter - good, fast and cheap; pick two.

Two questions (try to answer them all, you have a tendency to skip
answering important questions by being evasive):

1.  What will the unmodified WillHalt program (which you claim is your
counter example to the halting problem) determine if you give it the
program LoopIfHaltsOnItself with the input LoopIfHaltsOnItself (where
LoopIfHaltsOnItself is constructed with a modified WillHalt)?

2. If you are so convinced that we are all wrong and you are right,
why don't you take your discovery to the world? It would be an
important find (if it were true), so why aren't you announcing it to
the whole scientific community? You'd be famous, so what is stopping
you?

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:YV%Kc.286732$Gx4.147661@bgtnsc04-news.ops.worldnet.att.net...
| > 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'.
|
| They why is it that no one has found a single valid refutation?

I quite agree, no one has found a valid refutation of the Halting
Problem Conclusion.  Thank you for accepting that.
--
)>==ss$$%PARR(�>   Parr

"Kent Paul Dolan" <xanthian@well.com> wrote in message
news:052f4ea3d0180d3e8accfd568c3155cb.48257@mygate.mailgate.org...
| "Peter Olcott" <olcott@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.

I disagree.

To claim that one has a refutation
of a well established theorem, and
to back it up with a public
statement of the rationale, is
courageous, albeit somewhat naive.
He is being ridiculed because he;
who may possibly have found an
ingenious new principle which us
dinosaurs, not yet fully familiar
with newfangled multi-processing,
interrupt-driven, _proper_
computers can comprehend; because
he cannot be bothered to learn the
various skills and techniques to
put across his idea comprehendably.

As it happens, I have a gut feel
that's there's an important
principle to be learnt from his
approach.  I intend to refine it
in a way Peter is clearly unable
to, and use it as my own and
become famous, and rich, stinking
rich.

Peter, by messing me about when I
was trying to get him to arrive at
a clear and logically correct
statement of his refutation, and
thus end the argument, has annoyed
me and I have now absolutely no
qualms in stealing his idea which
is in the public domain and, with
my clarifications, will be my
copyright.
--
<�)PARRparr==<(   Parr

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:1Z%Kc.286746$Gx4.104836@bgtnsc04-news.ops.worldnet.att.net...
|
| "Kent Paul Dolan" <xanthian@well.com> wrote in message
news:052f4ea3d0180d3e8accfd568c3155cb.48257@mygate.mailgate.org...
| > "Peter Olcott" <olcott@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.

Why 17?  Only needs one.  Exaggeration is a
sign of immature thinking.  Grow up, child.
Grow up if you want to play with the big boys.

And what do you mean by refutations?
Refutations of what?  Unqualified, 'refutations'
is unclear.  Make yourself clear, child.  Make
yourself clear if you want to play with the big
boys.

| About all that I am getting is the Ad Hominem
| and/or Ad Vericundiam fallacies from most of you.

About all, but not all.

Certainly not from me.  All you got from me were
the first few of the many suggestions needed for
you to formalise your statements.

Deliberately, I based that formalisation on your
own material, material which you insisted people
must read.  And then you complain that one of
my clarifying statements, using terminology
which you yourself proposed, was too cryptic.

What do you mean by 'too cryptic'?  Do you mean
that you do not understand the stuff you quoted?
That you do not understand the Halting Problem in the version you
quoted?  Learn to understand the
subject you are dabbling in, child.  Learn to
understand the subject you are dabbling in if you
want to play with the big boys.

| I have not received a single valid refutation.

And why repeat yourself?  You have said it.  We
have read it.  Once was enough.  Repetition of
lies is a device used by politicians, not by
logical thinkers.  Learn to think logically,
child.  Learn to think logically if you want to
play with the big boys.

| Nothing at all that you said has been even in the ballpark
| of as much as an incorrect refutation.

There are three fundamental flaws in your
refutation which have been pointed out many times
and in many ways.  If you can't undestand these,
that your problem.  Learn to understand, child.
Learn to understand if you want to play with the
big boys.
--
)>==ss$$%PARR(�>   Parr

Peter Olcott wrote:
> You can make any assumption that is possible. You can not make
> any assumption that is not possible. I am not going to bother responding
> to the rest until we reach agreement on the prior. Do you understand
> what a proof by counter-example is? If you do please elaborate, if you
> do not, you won't be able to understand what I am saying.
> 
> NOTE Your responses above seemed to indicate that you are
> not fully conversant with the concept of proof by counter-example.

- How about:

 
http://zimmer.csufresno.edu/~larryc/proofs/proofs.contradict.html

   http://cs.wwc.edu/~aabyan/Logic/ProofTech.html

- I'm not sure what it is now that is being discussed but if
it happens to be Turing's proof, it is most likely to be
called a proof by contradiction. As you say, the "thing"
called a counterexample (the hypothesized self-referential
TM) creates a logical contradiction. You're right, this
"thing" doesn't exist. That's the point. First it is
hypothesized to exist, then deductions are made which lead
to a contradiction, therefore some hypothesis must be false 
(either the specific hypothesis made (the existence of this 
"thing", or some aspect of the system (definition of TM, 
logical inference, etc.). That is a perfectly good example
of proof by contradiction. Yes, it seems weird. Logic is not
obvious.


-- 
Mitch Harris
(remove q to reply)

Peter Olcott wrote:
> 
> No Solution to the halting Problem can possibly exist,
> It can't exist because Y makes it impossible.
> Wait Z can eliminate Y. Once Y is gone, then
> the proof by contradiction loses its contradiction.

Hmmm... this sounds ok to me.
But I've lost in the deluge what Z is.

Whatever Z is, is it true, a hypothesis, a change in 
inference rule, or what?

-- 
Mitch Harris
(remove q to reply)

Peter Olcott wrote:
> I am not nearly as
> good with words as I am with logic, that (and/or Groupthink)
> is why most people have not yet fully understood what I
> am saying.

appeal to authority and its varieties is a fallacy that
every science is susceptible to. Of all the sciences,
mathematics is the least susceptible because everybody has
access to the same data, and can do the same experiments to
corroborate or falsify. If you want to convince people,
citing Groupthink as a parry is not likely to be a succesful
strategy.

-- 
Mitch Harris
(remove q to reply)

"Peter Olcott" <olcott@worldnet.att.net> wrote in 
news:SkiLc.292234$Gx4.76830@bgtnsc04-news.ops.worldnet.att.net:

> I am not nearly as
> good with words as I am with logic

Your logic is so bad that I would have thought it unlikely that you could 
be any worse with anything than you are with logic.  But hey, if you 
insist...




-- 
CodeCutter - good, fast and cheap; pick two.

Peter Olcott wrote:
> "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m41qjFik5t1U1@uni-berlin.de...
>>Peter Olcott wrote:
 >>
>>> 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
> 
> That's not a valid refutation either. Yes I am a
> rugged individualist. All the conformists gave up
> long ago, I guess that's why it was so easy.

I agree, it's not a valid refutation of your arguments. It 
just seems that you are not persuaded by logical arguments. 
Also, I'm preaching to the choir.

All of those kinds of fallacies are fallacious when they are
irrelevant to an argument. But they can be very relevant.
Appealing to the authority of Turing is very relevant
because he has been shown over and over again to have been
correct (er.. in this very instance).

-- 
Mitch Harris
(remove q to reply)

Peter Olcott wrote:
>>just produce the code.  That would be a counter-example, not all the
>>stuff you've been saying.
> 
> Yeah right, like this is a reasonable requirement.

You claim that you have refuted Turing's proof because you have come up 
with a correct halting function. So, yes, it is a *very* reasonable 
requirement.

groente
-- Sander

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:x0lLc.131965$%_6.1311@attbi_s01...
> Peter Olcott wrote:
> > So you are saying that a machine that can not be transformed into a
> > Turing Machine, yet can correctly determine whether or not any other
> > software system (including Turing Machines) halts, would not solve
> > the Halting Problem because it is not implemented as a Turing Machine?
>
> Exactly so.  If it requires a model of computation more powerful
> than a regular Turing Machine, it says nothing at all about the

But the Church-Turing thesis says that there can't be a machine
more powerful than a Turing Machine. Also adding a screen
and protected memory to a computer does not make it more
powerful, except that this might solve the Halting Problem.

I doubt that you can find anything anywhere in the academic
research that says adding a screen to a machine that solves
the Halting Problem, makes this solution not count.

> strengths or limitations of a Turing Machine, and is therefore
> irrelevant to a discussion of the Halting Problem.
>

<stephen@nomail.com> wrote in message news:cdkmm3$1rr5$1@msunews.cl.msu.edu...
> In comp.theory Peter Olcott <olcott@worldnet.att.net> wrote:
>
> : So you are saying that a machine that can not be transformed into a
> : Turing Machine, yet can correctly determine whether or not any other
> : software system (including Turing Machines) halts, would not solve
> : the Halting Problem because it is not implemented as a Turing Machine?
>
> The important fact is not that it is not implemented as a Turing Machine,
> but that it *cannot be implemented* as a Turing Machine.   Your last
> phrase should be
> 'because it cannot be implemeted as a Turing Machine.'
>
> Stephen
>

I don't think that you can find anything anywhere that says that any
solution to the Halting Problem must be limited to a Turing Machine,
otherwise it does not count.

"No Way" <Not@real.com> wrote in message news:di7sf0pioe9417u4nhkikh3op9qun6bsrq@4ax.com...
> Two questions (try to answer them all, you have a tendency to skip
> answering important questions by being evasive):
>
> 1.  What will the unmodified WillHalt program (which you claim is your
> counter example to the halting problem) determine if you give it the
> program LoopIfHaltsOnItself with the input LoopIfHaltsOnItself (where
> LoopIfHaltsOnItself is constructed with a modified WillHalt)?

Line01)  void WillHalt(string SourceCode, string InputData)
Line02)  {
Line03)    if (TheProgramWillHalt(SourceCode, InputData))
Line04)        SecureOutput("The Program Will Halt");
Line05)    else if (TheProgramWillNotHalt(SourceCode, InputData))
Line06)        SecureOutput("The Program Will Not Halt");
Line07)    else
Line08)        SecureOutput("Security Has Been Breached, Take Corrective Action");
Line09)  }

Line08

> 2. If you are so convinced that we are all wrong and you are right,
> why don't you take your discovery to the world? It would be an
> important find (if it were true), so why aren't you announcing it to
> the whole scientific community? You'd be famous, so what is stopping
> you?

I want to debug my wording first. My wording has never changed
the meaning of what I am saying in this thread. I am striving to
present it more clearly.

"No Way" <Not@real.com> wrote in message news:di7sf0pioe9417u4nhkikh3op9qun6bsrq@4ax.com...
> Two questions (try to answer them all, you have a tendency to skip
> answering important questions by being evasive):
>
> 1.  What will the unmodified WillHalt program (which you claim is your
> counter example to the halting problem) determine if you give it the
> program LoopIfHaltsOnItself with the input LoopIfHaltsOnItself (where
> LoopIfHaltsOnItself is constructed with a modified WillHalt)?

It looks like this might be the counter-example that proves me wrong.
The guys on the C++ newsgroup found this counter-example on their
first try. I am not 100% certain that there is no way around this. It does
look like the very first valid refutation.

> 2. If you are so convinced that we are all wrong and you are right,
> why don't you take your discovery to the world? It would be an
> important find (if it were true), so why aren't you announcing it to
> the whole scientific community? You'd be famous, so what is stopping
> you?

Peter Olcott wrote:
> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:x0lLc.131965$%_6.1311@attbi_s01...
>>Peter Olcott wrote:
> 
> But the Church-Turing thesis says that there can't be a machine
> more powerful than a Turing Machine. 

No, it doesn't. It says that the many formalisms that happen
to be just as powerful as a TM are what we should all agree
on as the most appropriate formalism in which to discuss
computation.

> Also adding a screen
> and protected memory to a computer does not make it more
> powerful, 

OK. to me that means you can't do anything with these two 
additional properties that you can't do without. So any 
proof using these two things can be done without (and vice 
versa).

> except that this might solve the Halting Problem.

this may seem like begging the question to you, since you
have not accepted the proof that every one else accepts, but
by your previous statement (that adding a "screen" and
"protected memory" adds no power, to which I agree) this is
contradictory. If your proposed machine could solve the
Halting problem, then it would be more powerful than your
everyday TM. If it is as powerful as TMs, then it cannot
solve the Halting problem.

> I doubt that you can find anything anywhere in the academic
> research that says adding a screen to a machine that solves
> the Halting Problem, makes this solution not count.

I was about to say "I agree" (because 1) no one would bother
to take the time to do such a search for a nonentity, and 2)
because I would find it difficult to imagine such additions
being publishable in such language).

But a reasonable interpretation of your additions ("screen"
sounds like write only memory, and protected memory sounds
like... well.. like... memory.) And these restrictions,
shoot lets add in read only memory, that's a little more
useful, these restrictions have been proved to be no
restrictions at all (these kinds of TM modifications are
excellent homework style problems, like multitape, or multi
head)

If you are saying that your new kind of machine, has
particular restrictions, such that there is a procedure
(doesn't have to be the same kind of machine, could be a TM
or a very lucky geiger counter) to determine if any given
machine of your new kind halts or not on given input, well,
that's no surprise. There are all sorts of machines for
which this is known (some of which have already been
mentioned: FSAs, linear bounded automata).

I'm sorry but none of this sounds convincing. Not that it is
not true, just that they are just simple statements, not
even an attempt at convincing.

-- 
Mitch Harris
(remove q to reply)

"No Way" <Not@real.com> wrote in message news:di7sf0pioe9417u4nhkikh3op9qun6bsrq@4ax.com...
> Two questions (try to answer them all, you have a tendency to skip
> answering important questions by being evasive):
>
> 1.  What will the unmodified WillHalt program (which you claim is your
> counter example to the halting problem) determine if you give it the
> program LoopIfHaltsOnItself with the input LoopIfHaltsOnItself (where
> LoopIfHaltsOnItself is constructed with a modified WillHalt)?

Whoops sorry, I am wrong that I am wrong.
void WillHalt() would determine that LoopIfHaltsOnSelf() would halt.

> 2. If you are so convinced that we are all wrong and you are right,
> why don't you take your discovery to the world? It would be an
> important find (if it were true), so why aren't you announcing it to
> the whole scientific community? You'd be famous, so what is stopping
> you?

Peter Olcott wrote:
> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:x0lLc.131965$%_6.1311@attbi_s01...
> 
>>Peter Olcott wrote:
>>
>>>So you are saying that a machine that can not be transformed into a
>>>Turing Machine, yet can correctly determine whether or not any other
>>>software system (including Turing Machines) halts, would not solve
>>>the Halting Problem because it is not implemented as a Turing Machine?
>>
>>Exactly so.  If it requires a model of computation more powerful
>>than a regular Turing Machine, it says nothing at all about the
> 
> 
> But the Church-Turing thesis says that there can't be a machine
> more powerful than a Turing Machine. Also adding a screen
> and protected memory to a computer does not make it more
> powerful, except that this might solve the Halting Problem.

Here's a trivial proof:  Your program can model any Turing Machine,
so your program is at least as powerful as a Turing Machine.  But no
Turing Machine can model your program (otherwise it could simulate
your program and return a result, but then it couldn't exist
because of the Halting Problem).  So your program must be more
powerful than a Turing Machine.  QED.

Peter Olcott wrote:
> I don't think that you can find anything anywhere that says that any
> solution to the Halting Problem must be limited to a Turing Machine,
> otherwise it does not count.

Here is an exact analogy:

Turing says: The number 3 is less than the number 5
Olcott says: The number 6 is greater than the number 5, therefore Turing
is wrong.

Saying that 6 is greater than 5 does not make 3 greater than 5
because 6 is greater than 3.

Saying that your program can tell when any program halts does not
make it possible to construct a Turing machine that can tell when
any program halts because your program is more powerful than a
Turing Machine.

See the parallel?

Peter,

Since you've responded to me, I can only assume that you truly want an
open dialog on this issue.  If this is the case then great, I'd be
happy to discuss with you.  If I am wrong and you simply want to
'convince' me that you have solved the halting problem then please let
me know, I would rather not have such a dialog.

So for now I will proceed as though you want an open dialog.

I have read your website and I understand what you are saying.  You
are working within a programming language (call it PeterLanguage) that
allows only a subset of all possible programs.  You are showing that,
perhaps, it is possible to determine whether or not a particular set
of programs halt, but your set does not contain all possible programs
and the Halting Problem asks in terms of all possible programs. 
Please let me know if you understand this?

I've presented the standard recursion theoretic proof of the halting
problem below, which I hope will clear things up a bit.  I assume that
you've seen Cantor's proof that the Reals are uncountable?  This is a
similar diagonalization argument (I will go over it again):

We enumerate all possible Turing machine (this can be done because a
TM is simply a finite string over a finite alphabet.  These are, now,
all possible computer programs - the whole kaboodle:

     tm_1 tm_2 tm_3 [...]
tm_1   1    0    1  [...]
tm_2   0    0    1  [...]
tm_3   1    1    0  [...]
[...]

In addition, (x, y) = 1 if tm_x(tm_y) halts and it is 0 if tm_x(tm_y)
does not halt.  Again, these are the only two possibilities, something
cannot sort-of halt ... in fact, let's DEFINE 'does not halt' as
follows:

A TM does not halt if it is not the case that it halts.

It should be excrutiatingly clear that a TM either halts or not ...

If the halting problem is solvable (as you claim it is), then
certainly this program is solvable:

D(x) {
  if Halt(x, x) = 'No' then Halt
  else Loop Forever 
}

Now the question becomes, is this a TM?

Well, we have a list of TMs, let's see if it's in the list:

Is it TM_1?  Well, it cannot be, because

D(TM_1) = if Halt(TM_1, TM_1) = 'No' then Halt else Loop Forever

And we can clearly see that TM_1(TM_1) halts (from the graph that I've
constructed), so D(TM_1) does not halt.

Is it TM_n?  Well, it cannot be, because

D(TM_n) = if Halt(TM_n, TM_n) = 'No' then Halt else Loop Forever

And we can clearly see that if TM_n(TM_n) halts then D does not halt
and if TM_n(TM_n) does not halt then D halts.

It, therefore, cannot be any Turing Machines in the list of all Turing
Machines.  D is not a Turing Machine and, therefore, Halt is not a
Turing Machine.

I will try to anticipate your reply (I hope that I am wrong):

We cannot compile a program with the line D(TM_n) if we cannot
determine whether or not TM_n halts.  This is fine, no problem, REMOVE
a finite number of TMs from the list that you don't like ... certainly
none of them are the HALT program that you're looking for since you've
hand picked them as ones that you don't like because they 'use' the
halt program to cause a paradox (in fact you will remove no TMs from
the list because there is no Halt program and, therefore, there is no
paradox to be caused).  Please, again, let me know if this makes any
sense.  Please do not simply write one line and tell me that I am
wrong - let me know if you understand my argument and, if not, where
it is confusing.  Once you understand my argument then we can talk
more about whether or not you've solved the halting problem.

Kevin

"Peter Olcott" <olcott@worldnet.att.net> wrote in message news:<0eiLc.292197$Gx4.51255@bgtnsc04-news.ops.worldnet.att.net>...
> "Kevin Stern" <K-Stern@neiu.edu> wrote in message news:ca77e32d.0407191227.2715e440@posting.google.com...
> > void LoopIfHalts(string SourceCode, string InputData)
> > {
> >   if (WillHalt(SourceCode, InputData) == TRUE)
> >     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).
> 
> http://home.att.net/~olcott/halting/example.html
> examine this and get back to me
> 
> 
> > 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" <olcott@worldnet.att.net> wrote in message news:<xCOKc.111569$OB3.81647@bgtnsc05-news.ops.worldnet.att.net>...
> > > "Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns952B8AF6F38FCnobodynotmailcom@61.9.191.5...
> > > > "Peter Olcott" <olcott@worldnet.att.net> wrote in
> > > > news:UHwKc.277072$Gx4.4006@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.
> > >
> > > > 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 wrote:

> "Will Twentyman" <wtwentyman@read.my.sig> wrote in message news:40fdceb5_3@newsfeed.slurp.net...
> 
>>Peter Olcott wrote:
>>
>>
>>>>>>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.
>>>
>>>One programs is greater than no program, don't you agree?
>>>Only one more  than none is required to refute this claim.
>>
>>You offer a function:
>>
>>void POWillHalt(string function, string input)
>>{
>>  [do stuff to figure out if function(input) halts]
>>  cout << result;
>>}
> 
> If I can provide any means to refute the statement below, I have refuted the HAlting Problem.
> No program can ever be written to determine whether any arbitrary program will halt
> 
> It does not matter what you do with this solution, after the fact. It has already
> been correctly refuted.

1) To refute it, there must be a program that *does* determine if a 
given program and input results in halting or not halting.
2) My understanding of your proposal for the appearance of such a 
program is outlined above.
3) It can be readily modified to the outline below.
4) The outline below leads to a contradiction as illustrated in the 
standard proof that WillHalt() does not exist.
5) Therefore, the outline below does not operate as claimed.
6) If it doesn't operate as claimed, neither does the one above.
7) Therefore, your idea of protected memory and output to screen fails.

Where am I missing something?  At what step is there an error in the logic?

>>I can change it to
>>
>>bool StandardWillHalt(string function, string input)
>>{
>>  [do stuff to figure out if function(input) halts]
>>  return result;
>>}
>>
>>If you can't offer the source code, you can't claim to have the
>>solution.  If you can offer the source code, I can modify how it does
>>the output so that we can construct the standard contradiction.  This
>>should strongly suggest that your code didn't work as advertised.


-- 
Will Twentyman
email: wtwentyman at copper dot net

Peter Olcott wrote:

> "Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns952D9CBB490B0nobodynotmailcom@61.9.191.5...
> 
>>"Peter Olcott" <olcott@worldnet.att.net> wrote in
>>news:EiiLc.292221$Gx4.63033@bgtnsc04-news.ops.worldnet.att.net:
>>
>>
>>>I
>>>am not the best writer, and that is part of the problem.
>>>
>>
>>But Peter, you are a expert in semantics; remember?  You understand your
>>arguments with unmatchable clarity.  How can it possibly be that you aren't
>>the most accurate and effective writer on the planet?
>>
>>
>>-- 
>>CodeCutter - good, fast and cheap; pick two.
> 
> 
> It a well known fact that those that are good at logic/math
> are not good a writing. It has to do with the size of the Corpus
> Callosum.

I'll have to go tell my wife to stop being good at one of them.  I 
wonder which one she'll pick.

-- 
Will Twentyman
email: wtwentyman at copper dot net

Peter Olcott wrote:

> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:x0lLc.131965$%_6.1311@attbi_s01...
> 
>>Peter Olcott wrote:
>>
>>>So you are saying that a machine that can not be transformed into a
>>>Turing Machine, yet can correctly determine whether or not any other
>>>software system (including Turing Machines) halts, would not solve
>>>the Halting Problem because it is not implemented as a Turing Machine?
>>
>>Exactly so.  If it requires a model of computation more powerful
>>than a regular Turing Machine, it says nothing at all about the
> 
> 
> But the Church-Turing thesis says that there can't be a machine
> more powerful than a Turing Machine. Also adding a screen
> and protected memory to a computer does not make it more
> powerful, except that this might solve the Halting Problem.

Incorrect.  http://en.wikipedia.org/wiki/Oracle_machine  An Oracle 
machine is a TM with a special oracle function added.  The oracle 
function can be anything, including WillHalt(), but is generally 
something that cannot be implemented on a TM.  Such a device is more 
powerful than a TM.

-- 
Will Twentyman
email: wtwentyman at copper dot net

Peter Olcott wrote:

> <stephen@nomail.com> wrote in message news:cdkmm3$1rr5$1@msunews.cl.msu.edu...
> 
>>In comp.theory Peter Olcott <olcott@worldnet.att.net> wrote:
>>
>>: So you are saying that a machine that can not be transformed into a
>>: Turing Machine, yet can correctly determine whether or not any other
>>: software system (including Turing Machines) halts, would not solve
>>: the Halting Problem because it is not implemented as a Turing Machine?
>>
>>The important fact is not that it is not implemented as a Turing Machine,
>>but that it *cannot be implemented* as a Turing Machine.   Your last
>>phrase should be
>>'because it cannot be implemeted as a Turing Machine.'
>>
>>Stephen
>>
> 
> 
> I don't think that you can find anything anywhere that says that any
> solution to the Halting Problem must be limited to a Turing Machine,
> otherwise it does not count.

No, but it has to be something equivalent to a Turing Machine to count. 
  For your screen idea to work, it must necessarily not be equivalent to 
a Turing Machine.

-- 
Will Twentyman
email: wtwentyman at copper dot net

In comp.theory Will Twentyman <wtwentyman@read.my.sig> wrote:
: Peter Olcott wrote:

:> <stephen@nomail.com> wrote in message news:cdkmm3$1rr5$1@msunews.cl.msu.edu...
:> 
:>>In comp.theory Peter Olcott <olcott@worldnet.att.net> wrote:
:>>
:>>: So you are saying that a machine that can not be transformed into a
:>>: Turing Machine, yet can correctly determine whether or not any other
:>>: software system (including Turing Machines) halts, would not solve
:>>: the Halting Problem because it is not implemented as a Turing Machine?
:>>
:>>The important fact is not that it is not implemented as a Turing Machine,
:>>but that it *cannot be implemented* as a Turing Machine.   Your last
:>>phrase should be
:>>'because it cannot be implemeted as a Turing Machine.'
:>>
:>>Stephen
:>>
:> 
:> 
:> I don't think that you can find anything anywhere that says that any
:> solution to the Halting Problem must be limited to a Turing Machine,
:> otherwise it does not count.

: No, but it has to be something equivalent to a Turing Machine to count. 
:   For your screen idea to work, it must necessarily not be equivalent to 
: a Turing Machine.

And if it is more powerful than a Turing Machine, you cannot write an 
equivalent program in any known programming language.  All of Peter's
"examples" use a C/C++ like syntax, so I assume he thinks he could actually
write his program in C.  If he could do that, it cannot be more powerful
than a Turing Machine.

Stephen

Marc Goodman <marc.goodman@comcast.net> writes:
 : Saying that your program can tell when any program halts does not
 : make it possible to construct a Turing machine that can tell when
 : any program halts because your program is more powerful than a
 : Turing Machine.
 : 
 : See the parallel?

He will insist that he STILL deserves a prize because the
Church-Turing thesis is that NO programming paradigm (under-
standable by humans anyway) is more powerful than a Turing Machine.
If you concede that he's designed one, he thinks that is even MORE
important than designing a "solution" to the halting problem.

-- 
 --- 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

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:YV%Kc.286732$Gx4.147661@bgtnsc04-news.ops.worldnet.att.net...

Jesus!  This twerp can't even identify to what, and to whom he is
replying!

| > 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'.
|
| WillHalt(string SourceCode, string InputData) is far less cryptic.

Nowhere in your maundering, meandering, meaningless, muddled,
mistaken 'refutation' in:
http://home.att.net/~olcott/halting/index.html
do you use the 'far less cryptic' equivalent which
you now draw out of your hat like a conjuror's
bunny wabbit.

Get yer beans in a row, boyo!  Then may you essay
to bugger me gently with the rough end of a
rotating pineapple.

I can hardly believe I have spent the time I have
attempting to help someone who clearly needed a
bit of advice on logic and computer theory
because they were manifestly lacking in the
skills necessary.

So now I chuckle to myself, 'Tee-hee, gadzooks
i'faith, the silly sod discovereth something
important and hath not the wit to cash in on
it.  And his fluffy wit will not be able to
gainsay my theft of his brainchild from which I
will make myself famous and rich, stinking
rich.'

~~~~~~~
Footnote:
Christopher Stevens of Eastleigh, Hampshire, UK,
suddenly stopped his trolling in one ng when his
true name, address and phone numer were
published.
--
)>==ss$$%PARR(�>   Parr

Bloody hell!.  I don't understand, Kevin.  Where can I obtain a
degree in the extraction of micturate such as you clearly must
posses.

BTW, to make this comprehensable to Peeter, shouldn't you have spelt
"outputs" as "output's"?
--
)>==ss$$%PARR(�>   Parr

"Kevin Stern" <K-Stern@neiu.edu> wrote in message
news:ca77e32d.0407191227.2715e440@posting.google.com...
| void LoopIfHalts(string SourceCode, string InputData)
| {
|   if (WillHalt(SourceCode, InputData) == TRUE)
|     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" <olcott@worldnet.att.net> wrote in message
news:SkiLc.292234$Gx4.76830@bgtnsc04-news.ops.worldnet.att.net...
|
| "Daryl McCullough" <daryl@atc-nycorp.com> wrote in message
news:cdj3oq01tku@drn.newsguy.com...
| > Peter Olcott says...
| >
| > >They why is it that no one has found a single valid refutation?
| >
| > Peter, the reason you *believe* that no one has found a
refutation
| > is because you are not competent to recognize a valid argument
when
| > you see one. You have been given many valid refutations, and you
| > were no more able to understand them than my cat.
|
| Sorry, not true. Not only were most of the refutations not
| valid, most were also provably false. I am not nearly as
| good with words as I am with logic, that (and/or Groupthink)
| is why most people have not yet fully understood what I
| am saying.

So, most, but not all, were provably false; most, but not all were
provably not valid?

Thank you for acknowledging that sci.logic has at least one
subscriber who has, to your satisfaction, shown your burblings to be
the crap which we all knew they were.
--
)>==ss$$%PARR(�>   Parr

Peter Olcott says...
>
>
>"Daryl McCullough" <daryl@atc-nycorp.com> wrote

>> Peter, the reason you *believe* that no one has found a refutation
>> is because you are not competent to recognize a valid argument when
>> you see one. You have been given many valid refutations, and you
>> were no more able to understand them than my cat.

>Sorry, not true. Not only were most of the refutations not
>valid, most were also provably false.

Like I said, Peter. You have no idea what is true, what is
false, what is valid and what is fallacious. You are a
complete incompetent at logical reasoning. The fact that
you *believe* that you haven't been refuted is irrelevant.

--
Daryl McCullough
Ithaca, NY

  >parr(*> wrote:
> So now I chuckle to myself, 'Tee-hee, gadzooks
> i'faith, the silly sod discovereth something
> important and hath not the wit to cash in on
> it. 

"He is winding the watch of his wit; by and by it will strike."

> http://zimmer.csufresno.edu/~larryc/proofs/proofs.contradict.html
>
>    http://cs.wwc.edu/~aabyan/Logic/ProofTech.html
>
> - I'm not sure what it is now that is being discussed but if
> it happens to be Turing's proof, it is most likely to be
> called a proof by contradiction. As you say, the "thing"
> called a counterexample (the hypothesized self-referential
> TM) creates a logical contradiction. You're right, this
> "thing" doesn't exist. That's the point. First it is
> hypothesized to exist, then deductions are made which lead
> to a contradiction, therefore some hypothesis must be false
> (either the specific hypothesis made (the existence of this
> "thing", or some aspect of the system (definition of TM,
> logical inference, etc.). That is a perfectly good example
> of proof by contradiction. Yes, it seems weird. Logic is not
> obvious.
>
>
> -- 
> Mitch Harris
> (remove q to reply)
>
All that I need to do is to make the original counter-example
impossible to create in at least one instance, then I have provided
the counter-counter-example.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m6n1uFjj9mtU1@uni-berlin.de...
> Peter Olcott wrote:
> >
> > No Solution to the halting Problem can possibly exist,
> > It can't exist because Y makes it impossible.
> > Wait Z can eliminate Y. Once Y is gone, then
> > the proof by contradiction loses its contradiction.
>
> Hmmm... this sounds ok to me.
> But I've lost in the deluge what Z is.
>
> Whatever Z is, is it true, a hypothesis, a change in
> inference rule, or what?
>
> -- 
> Mitch Harris
> (remove q to reply)
>

LoopIfHalts() is "Y"
void WillHalt() is "Z".

Z makes Y impossible to create.

counter-counter-example.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m6ng9Fjjno7U1@uni-berlin.de...
> Peter Olcott wrote:
> > I am not nearly as
> > good with words as I am with logic, that (and/or Groupthink)
> > is why most people have not yet fully understood what I
> > am saying.
>
> appeal to authority and its varieties is a fallacy that
> every science is susceptible to. Of all the sciences,
> mathematics is the least susceptible because everybody has
> access to the same data, and can do the same experiments to
> corroborate or falsify. If you want to convince people,
> citing Groupthink as a parry is not likely to be a succesful
> strategy.
>
> -- 
> Mitch Harris
> (remove q to reply)
>

Whether it is a successful strategy is not my point.
I only seek the actual truth, regardless of the consequences.
It sure looks like GroupThink is operating here.

> All of those kinds of fallacies are fallacious when they are
> irrelevant to an argument. But they can be very relevant.

Fallacies are always errors.

> Appealing to the authority of Turing is very relevant
> because he has been shown over and over again to have been
> correct (er.. in this very instance).
>
> -- 
> Mitch Harris
> (remove q to reply)
>

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m77adFjrmccU1@uni-berlin.de...
> Peter Olcott wrote:
> > "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:x0lLc.131965$%_6.1311@attbi_s01...
> >>Peter Olcott wrote:
> >
> > But the Church-Turing thesis says that there can't be a machine
> > more powerful than a Turing Machine.
>
> No, it doesn't. It says that the many formalisms that happen
> to be just as powerful as a TM are what we should all agree
> on as the most appropriate formalism in which to discuss
> computation.

Turing Thesis (my text gives no credit to Church):
Any computation that can be carried out by mechanical
means can be performed by some Turing Machine.

This seems to agree much more with what I said, than wht you said.

> this may seem like begging the question to you, since you
> have not accepted the proof that every one else accepts, but

It is not merely that I have not accepted a proof that everyone
else accepts. It is that my disprove of this proof has not yet
been found in error. If you think that any of the refutations of
my refutation were valid, then state which one(s).  I have
found serious flaws in everyone of them.

> by your previous statement (that adding a "screen" and
> "protected memory" adds no power, to which I agree) this is

Not necessarily. The Halting Problem might not be solved
without them.

> contradictory. If your proposed machine could solve the
> Halting problem, then it would be more powerful than your
> everyday TM. If it is as powerful as TMs, then it cannot
> solve the Halting problem.
> > I doubt that you can find anything anywhere in the academic
> > research that says adding a screen to a machine that solves
> > the Halting Problem, makes this solution not count.
>
> I was about to say "I agree" (because 1) no one would bother
> to take the time to do such a search for a nonentity, and 2)
> because I would find it difficult to imagine such additions
> being publishable in such language).
>
> But a reasonable interpretation of your additions ("screen"
> sounds like write only memory, and protected memory sounds
> like... well.. like... memory.) And these restrictions,
> shoot lets add in read only memory, that's a little more
> useful, these restrictions have been proved to be no
> restrictions at all (these kinds of TM modifications are
> excellent homework style problems, like multitape, or multi
> head)

Protected memory might be construed as beyond the capabilites
of a TM.

> If you are saying that your new kind of machine, has
> particular restrictions, such that there is a procedure
> (doesn't have to be the same kind of machine, could be a TM
> or a very lucky geiger counter) to determine if any given
> machine of your new kind halts or not on given input, well,
> that's no surprise. There are all sorts of machines for
> which this is known (some of which have already been
> mentioned: FSAs, linear bounded automata).
>
> I'm sorry but none of this sounds convincing. Not that it is
> not true, just that they are just simple statements, not
> even an attempt at convincing.

It is not meant to be convincing. Its meant to be a simple statement of
fact. If you change the form of the WillHalt() function such that its caller
has no possible access to its result, then the original Halting Problem
can not possibly be constructed. It really just as simple as that.


> -- 
> Mitch Harris
> (remove q to reply)
>

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:XuvLc.133840$a24.78695@attbi_s03...
> Peter Olcott wrote:
> > "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:x0lLc.131965$%_6.1311@attbi_s01...
> >
> >>Peter Olcott wrote:
> >>
> >>>So you are saying that a machine that can not be transformed into a
> >>>Turing Machine, yet can correctly determine whether or not any other
> >>>software system (including Turing Machines) halts, would not solve
> >>>the Halting Problem because it is not implemented as a Turing Machine?
> >>
> >>Exactly so.  If it requires a model of computation more powerful
> >>than a regular Turing Machine, it says nothing at all about the
> >
> >
> > But the Church-Turing thesis says that there can't be a machine
> > more powerful than a Turing Machine. Also adding a screen
> > and protected memory to a computer does not make it more
> > powerful, except that this might solve the Halting Problem.
>
> Here's a trivial proof:  Your program can model any Turing Machine,
> so your program is at least as powerful as a Turing Machine.  But no
> Turing Machine can model your program (otherwise it could simulate
> your program and return a result, but then it couldn't exist
> because of the Halting Problem).  So your program must be more
> powerful than a Turing Machine.  QED.
>

Turing Thesis:
Any computation that can be carried out by mechanical means
can be performed by some Turing Machine.

Hard to see how more powerful than this can exist.

> Saying that your program can tell when any program halts does not
> make it possible to construct a Turing machine that can tell when
> any program halts because your program is more powerful than a
> Turing Machine.
>
> See the parallel?
>
Turing's these says that more powerful that a TM can't exist.

> I have read your website and I understand what you are saying.  You
> are working within a programming language (call it PeterLanguage) that
> allows only a subset of all possible programs.  You are showing that,
> perhaps, it is possible to determine whether or not a particular set
> of programs halt, but your set does not contain all possible programs
> and the Halting Problem asks in terms of all possible programs.
> Please let me know if you understand this?

No this is not quite it.
I have redefined the Halting analyzer such that the counter-example
program that shows that solving the Halting Problem is impossible
can not exist.

The basic way of doing this is essentially changing the halting analyzer
from returning Boolean to its caller, to returning nothing to its caller.

> I've presented the standard recursion theoretic proof of the halting
> problem below, which I hope will clear things up a bit.  I assume that
> you've seen Cantor's proof that the Reals are uncountable?  This is a
> similar diagonalization argument (I will go over it again):
>
> We enumerate all possible Turing machine (this can be done because a
> TM is simply a finite string over a finite alphabet.  These are, now,
> all possible computer programs - the whole kaboodle:
>
>      tm_1 tm_2 tm_3 [...]
> tm_1   1    0    1  [...]
> tm_2   0    0    1  [...]
> tm_3   1    1    0  [...]
> [...]
>
> In addition, (x, y) = 1 if tm_x(tm_y) halts and it is 0 if tm_x(tm_y)
> does not halt.  Again, these are the only two possibilities, something
> cannot sort-of halt ... in fact, let's DEFINE 'does not halt' as
> follows:
>
> A TM does not halt if it is not the case that it halts.
>
> It should be excrutiatingly clear that a TM either halts or not ...
>
> If the halting problem is solvable (as you claim it is), then
> certainly this program is solvable:
>
> D(x) {
>   if Halt(x, x) = 'No' then Halt
>   else Loop Forever
> }
>
> Now the question becomes, is this a TM?
>
> Well, we have a list of TMs, let's see if it's in the list:
>
> Is it TM_1?  Well, it cannot be, because
>
> D(TM_1) = if Halt(TM_1, TM_1) = 'No' then Halt else Loop Forever
>
> And we can clearly see that TM_1(TM_1) halts (from the graph that I've
> constructed), so D(TM_1) does not halt.
>
> Is it TM_n?  Well, it cannot be, because
>
> D(TM_n) = if Halt(TM_n, TM_n) = 'No' then Halt else Loop Forever
>
> And we can clearly see that if TM_n(TM_n) halts then D does not halt
> and if TM_n(TM_n) does not halt then D halts.
>
> It, therefore, cannot be any Turing Machines in the list of all Turing
> Machines.  D is not a Turing Machine and, therefore, Halt is not a
> Turing Machine.
>
> I will try to anticipate your reply (I hope that I am wrong):
>
> We cannot compile a program with the line D(TM_n) if we cannot
> determine whether or not TM_n halts.  This is fine, no problem, REMOVE
> a finite number of TMs from the list that you don't like ... certainly
> none of them are the HALT program that you're looking for since you've
> hand picked them as ones that you don't like because they 'use' the
> halt program to cause a paradox (in fact you will remove no TMs from
> the list because there is no Halt program and, therefore, there is no
> paradox to be caused).  Please, again, let me know if this makes any
> sense.  Please do not simply write one line and tell me that I am
> wrong - let me know if you understand my argument and, if not, where
> it is confusing.  Once you understand my argument then we can talk
> more about whether or not you've solved the halting problem.
>
> Kevin
>
> "Peter Olcott" <olcott@worldnet.att.net> wrote in message news:<0eiLc.292197$Gx4.51255@bgtnsc04-news.ops.worldnet.att.net>...
> > "Kevin Stern" <K-Stern@neiu.edu> wrote in message news:ca77e32d.0407191227.2715e440@posting.google.com...
> > > void LoopIfHalts(string SourceCode, string InputData)
> > > {
> > >   if (WillHalt(SourceCode, InputData) == TRUE)
> > >     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).
> >
> > http://home.att.net/~olcott/halting/example.html
> > examine this and get back to me
> >
> >
> > > 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" <olcott@worldnet.att.net> wrote in message news:<xCOKc.111569$OB3.81647@bgtnsc05-news.ops.worldnet.att.net>...
> > > > "Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns952B8AF6F38FCnobodynotmailcom@61.9.191.5...
> > > > > "Peter Olcott" <olcott@worldnet.att.net> wrote in
> > > > > news:UHwKc.277072$Gx4.4006@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.
> > > >
> > > > > 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.

> > If I can provide any means to refute the statement below, I have refuted the HAlting Problem.
> > No program can ever be written to determine whether any arbitrary program will halt
> >
> > It does not matter what you do with this solution, after the fact. It has already
> > been correctly refuted.
>
> 1) To refute it, there must be a program that *does* determine if a
> given program and input results in halting or not halting.
> 2) My understanding of your proposal for the appearance of such a
> program is outlined above.
> 3) It can be readily modified to the outline below.
> 4) The outline below leads to a contradiction as illustrated in the
> standard proof that WillHalt() does not exist.

It ONLY proves that bool WillHalt() does not exist.
It proves NOTHING about void WillHalt().

> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>

> > But the Church-Turing thesis says that there can't be a machine
> > more powerful than a Turing Machine. Also adding a screen
> > and protected memory to a computer does not make it more
> > powerful, except that this might solve the Halting Problem.
>
> Incorrect.  http://en.wikipedia.org/wiki/Oracle_machine  An Oracle
> machine is a TM with a special oracle function added.  The oracle
> function can be anything, including WillHalt(), but is generally
> something that cannot be implemented on a TM.  Such a device is more
> powerful than a TM.

Yet can't possibly exist. All this is magic, not computer science.
At least Turing Machines can mostly exist. No Infinite tape

>
> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>
>

"Will Twentyman" <wtwentyman@read.my.sig> wrote in message news:40fe9674$1_1@newsfeed.slurp.net...
> Peter Olcott wrote:
>
> > <stephen@nomail.com> wrote in message news:cdkmm3$1rr5$1@msunews.cl.msu.edu...
> >
> >>In comp.theory Peter Olcott <olcott@worldnet.att.net> wrote:
> >>
> >>: So you are saying that a machine that can not be transformed into a
> >>: Turing Machine, yet can correctly determine whether or not any other
> >>: software system (including Turing Machines) halts, would not solve
> >>: the Halting Problem because it is not implemented as a Turing Machine?
> >>
> >>The important fact is not that it is not implemented as a Turing Machine,
> >>but that it *cannot be implemented* as a Turing Machine.   Your last
> >>phrase should be
> >>'because it cannot be implemeted as a Turing Machine.'
> >>
> >>Stephen
> >>
> >
> >
> > I don't think that you can find anything anywhere that says that any
> > solution to the Halting Problem must be limited to a Turing Machine,
> > otherwise it does not count.
>
> No, but it has to be something equivalent to a Turing Machine to count.
>   For your screen idea to work, it must necessarily not be equivalent to
> a Turing Machine.
>
> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>

Another respondent suggested write only memory is the same
as a screen.

Peter Olcott wrote:
> Turing Thesis:
> Any computation that can be carried out by mechanical means
> can be performed by some Turing Machine.

OK, so you are now arguing that your program is not more powerful
than a Turing Machine (it either is or it isn't and you just said
it isn't).  Therefore your program can be simulated by a Turing
Machine that notices when your program hits lines 4, 7 and 10
in the program below and returns appropriate values, violating
the Halting Problem.  So, you program must either be more powerful
than a Turing Machine, which you now deny, or your program cannot
exist as detailed explicitly below.  You lose, have a nice day.


> I refer to the code from:
> 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

">parr(*>" <KurlyGina@tenretnitb.moc> wrote in message news:cdmlb7$dlb$2@hercules.btinternet.com...
> "Peter Olcott" <olcott@worldnet.att.net> wrote in message
> news:SkiLc.292234$Gx4.76830@bgtnsc04-news.ops.worldnet.att.net...
> |
> | "Daryl McCullough" <daryl@atc-nycorp.com> wrote in message
> news:cdj3oq01tku@drn.newsguy.com...
> | > Peter Olcott says...
> | >
> | > >They why is it that no one has found a single valid refutation?
> | >
> | > Peter, the reason you *believe* that no one has found a
> refutation
> | > is because you are not competent to recognize a valid argument
> when
> | > you see one. You have been given many valid refutations, and you
> | > were no more able to understand them than my cat.
> |
> | Sorry, not true. Not only were most of the refutations not
> | valid, most were also provably false. I am not nearly as
> | good with words as I am with logic, that (and/or Groupthink)
> | is why most people have not yet fully understood what I
> | am saying.
>
> So, most, but not all, were provably false; most, but not all were
> provably not valid?

Yeah its that ridiculous idea that a sound argument requires
both valid reasoning and true premises. Of course this is
laughably absurd.

> Thank you for acknowledging that sci.logic has at least one
> subscriber who has, to your satisfaction, shown your burblings to be
> the crap which we all knew they were.
> --
> )>==ss$$%PARR(�>   Parr
>
>
>

"Daryl McCullough" <daryl@atc-nycorp.com> wrote in message news:cdmm5e01opa@drn.newsguy.com...
> Peter Olcott says...
> >
> >
> >"Daryl McCullough" <daryl@atc-nycorp.com> wrote
>
> >> Peter, the reason you *believe* that no one has found a refutation
> >> is because you are not competent to recognize a valid argument when
> >> you see one. You have been given many valid refutations, and you
> >> were no more able to understand them than my cat.
>
> >Sorry, not true. Not only were most of the refutations not
> >valid, most were also provably false.
>
> Like I said, Peter. You have no idea what is true, what is
> false, what is valid and what is fallacious. You are a
> complete incompetent at logical reasoning. The fact that
> you *believe* that you haven't been refuted is irrelevant.
>
> --
> Daryl McCullough
> Ithaca, NY
>

And you can say this with a straight face knowing full well that
most of what people provided as "refutation" was one fallacy
or another.

Peter Olcott wrote:
> Yeah its that ridiculous idea that a sound argument requires
> both valid reasoning and true premises. Of course this is
> laughably absurd.

Peter Olcott Posting on 7/18/04 at 22:40:
> http://home.att.net/~olcott/halting/index.html#objection02
> Neither the Analyzer nor the Analyzed are limited to Turing Machines

Peter Olcott Posting on 7/21/04 at 20:13:
> Turing Thesis:
> Any computation that can be carried out by mechanical means
> can be performed by some Turing Machine.
> 
> Hard to see how more powerful than this can exist.

Which did you have wrong Peter, the valid reasoning or the true
premises?

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:wSDLc.6249$8_6.1023@attbi_s04...
> Peter Olcott wrote:
> > Turing Thesis:
> > Any computation that can be carried out by mechanical means
> > can be performed by some Turing Machine.
>
> OK, so you are now arguing that your program is not more powerful
> than a Turing Machine (it either is or it isn't and you just said
> it isn't).  Therefore your program can be simulated by a Turing
> Machine that notices when your program hits lines 4, 7 and 10
> in the program below and returns appropriate values, violating
> the Halting Problem.  So, you program must either be more powerful
> than a Turing Machine, which you now deny, or your program cannot
> exist as detailed explicitly below.  You lose, have a nice day.
>

I don't see why everyone here is not getting this:
Producing a version of WillHalt that does not work
in no way refutes another version that does work.

(a) void WillHalt() always works
(b) bool WillHalt() does not work on some inputs

From (b) you can conclude nothing at all about (a).

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:62ELc.136053$a24.80900@attbi_s03...
> Peter Olcott wrote:
> > Yeah its that ridiculous idea that a sound argument requires
> > both valid reasoning and true premises. Of course this is
> > laughably absurd.
>
> Peter Olcott Posting on 7/18/04 at 22:40:
> > http://home.att.net/~olcott/halting/index.html#objection02
> > Neither the Analyzer nor the Analyzed are limited to Turing Machines
>
> Peter Olcott Posting on 7/21/04 at 20:13:
> > Turing Thesis:
> > Any computation that can be carried out by mechanical means
> > can be performed by some Turing Machine.
> >
> > Hard to see how more powerful than this can exist.
>
> Which did you have wrong Peter, the valid reasoning or the true
> premises?
>

Several people here openly laughed at me for saying that
a sound argument required both true premises and valid
reasoning. They thought that the idea of true premises was
absurd. Amazingly enough they were not kidding, they
really thought that all reasoning only starts with arbitrary
assumptions.

"Peter Olcott" <olcott@worldnet.att.net> wrote in
news:cCELc.120965$OB3.56405@bgtnsc05-news.ops.worldnet.att.net: 

> Several people here openly laughed at me for saying that
> a sound argument required both true premises and valid
> reasoning. They thought that the idea of true premises was
> absurd. Amazingly enough they were not kidding, they
> really thought that all reasoning only starts with arbitrary
> assumptions.

Wow!  This logics expert still doesn't understand proof by contradiction.

If you make an arbitrary assumtion and follow through with correct 
reasoning and that leads to a contradiction, then what does that say about 
your arbitrary assumption?



-- 
CodeCutter - good, fast and cheap; pick two.

>>>>> "Peter" == Peter Olcott <olcott@worldnet.att.net> writes:

    Peter> Yet can't possibly exist. All this is magic, not computer
    Peter> science.

All you can say is that we don't know them exist now, and they don't
"seem" to exist.  The nature has all kinds of "strange" phenomena that
nearly everybody other than scientists in physics would call "magic".
If tomorrow atomic physics researchers tell us that there is a
physical phenomenon that would solve the halting problem of Turing
machines I won't be "too" surprised.

Regards,
Isaac.

"Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns952E754902780nobodynotmailcom@61.9.191.5...
> "Peter Olcott" <olcott@worldnet.att.net> wrote in
> news:cCELc.120965$OB3.56405@bgtnsc05-news.ops.worldnet.att.net:
>
> > Several people here openly laughed at me for saying that
> > a sound argument required both true premises and valid
> > reasoning. They thought that the idea of true premises was
> > absurd. Amazingly enough they were not kidding, they
> > really thought that all reasoning only starts with arbitrary
> > assumptions.
>
> Wow!  This logics expert still doesn't understand proof by contradiction.
>
> If you make an arbitrary assumtion and follow through with correct
> reasoning and that leads to a contradiction, then what does that say about
> your arbitrary assumption?

I am well aware that it is okay to start with assumptions
in some cases. They were unaware that it was ever okay
to start with anything besides assumptions. They thought
that starting with true premises was a crazy idea.

"Isaac To" <isaact@netscape.net> wrote in message news:87iscgzv0f.fsf@sinken.local.csis.hku.hk...
> >>>>> "Peter" == Peter Olcott <olcott@worldnet.att.net> writes:
>
>     Peter> Yet can't possibly exist. All this is magic, not computer
>     Peter> science.
>
> All you can say is that we don't know them exist now, and they don't
> "seem" to exist.  The nature has all kinds of "strange" phenomena that
> nearly everybody other than scientists in physics would call "magic".
> If tomorrow atomic physics researchers tell us that there is a
> physical phenomenon that would solve the halting problem of Turing
> machines I won't be "too" surprised.
>
> Regards,
> Isaac.

But, I have already solved this problem.
If the analyzer is changed so that it does not return its result
back to its caller, then what was called the "Halting Problem"
can not occur.  (Show me how it can occur if you disagree).

"Peter Olcott" <olcott@worldnet.att.net> wrote in
news:tiFLc.299189$Gx4.66833@bgtnsc04-news.ops.worldnet.att.net: 

> I am well aware that it is okay to start with assumptions
> in some cases. They were unaware that it was ever okay
> to start with anything besides assumptions. They thought
> that starting with true premises was a crazy idea.

OK, I think I actually did misread you this time.  Not that I now agree 
with you specific assesment of any specific person or persons (I have no 
idea to whom you might be referring).


-- 
CodeCutter - good, fast and cheap; pick two.

Peter Olcott wrote:
> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:wSDLc.6249$8_6.1023@attbi_s04...
> 
>>Peter Olcott wrote:
>>
>>>Turing Thesis:
>>>Any computation that can be carried out by mechanical means
>>>can be performed by some Turing Machine.
>>
>>OK, so you are now arguing that your program is not more powerful
>>than a Turing Machine (it either is or it isn't and you just said
>>it isn't).  Therefore your program can be simulated by a Turing
>>Machine that notices when your program hits lines 4, 7 and 10
>>in the program below and returns appropriate values, violating
>>the Halting Problem.  So, you program must either be more powerful
>>than a Turing Machine, which you now deny, or your program cannot
>>exist as detailed explicitly below.  You lose, have a nice day.
>>
> 
> 
> I don't see why everyone here is not getting this:
> Producing a version of WillHalt that does not work
> in no way refutes another version that does work.

1. That's true if and only if the other version works.
2. If it works and it's Turing Machine equivalent, it
    can be simulated by a Turing Machine.
3. If it can be simulated by a Turing Machine, and it's
    Turing Machine equivalent, then it will produce exactly
    the same results in simulation as it does running stand-alone.
4. If the simulator can run the program, it can tell what
    state the program is in and return that result.
5. Therefore, if 1 is true, then 4 is true.
6. 4 cannot possibly be true, so 1 cannot possibly be
    true.
7. Therefore, your program cannot possibly work.  QED.

Either you now accept that you have been full of shit this
entire time, or you can point to one of the above reasoning
steps that you disagree with.

> 
> (a) void WillHalt() always works

Not true by the above proof.

> (b) bool WillHalt() does not work on some inputs

They are exactly equivalent if your program is Turing
Machine equivalent by the above proof.

> From (b) you can conclude nothing at all about (a).

If B doesn't work, A cannot possibly exist.  B has been
proven to not work.  Therefore, A does not work.  Therefore
you are full of shit.

Peter Olcott wrote:
> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:62ELc.136053$a24.80900@attbi_s03...
> 
>>Peter Olcott wrote:
>>
>>>Yeah its that ridiculous idea that a sound argument requires
>>>both valid reasoning and true premises. Of course this is
>>>laughably absurd.
>>
>>Peter Olcott Posting on 7/18/04 at 22:40:
>>
>>>http://home.att.net/~olcott/halting/index.html#objection02
>>>Neither the Analyzer nor the Analyzed are limited to Turing Machines
>>
>>Peter Olcott Posting on 7/21/04 at 20:13:
>>
>>>Turing Thesis:
>>>Any computation that can be carried out by mechanical means
>>>can be performed by some Turing Machine.
>>>
>>>Hard to see how more powerful than this can exist.
>>
>>Which did you have wrong Peter, the valid reasoning or the true
>>premises?
>>
> 
> 
> Several people here openly laughed at me for saying that
> a sound argument required both true premises and valid
> reasoning. They thought that the idea of true premises was
> absurd. Amazingly enough they were not kidding, they
> really thought that all reasoning only starts with arbitrary
> assumptions.

This in no way answers the above question.  Here it is stated
more simply: Were you wrong that your program was not limited
to Turing machines, or were you wrong that any computation
that can be carried out by mechanical means can be performed
by some Turing machine, or were you wrong that your program
works.  It has to be one or the other.  Lucky you, you get
to pick exactly which mistake you made, and we'll proceed from
there.

>>>>> "Peter" == Peter Olcott <olcott@worldnet.att.net> writes:

    Peter> But, I have already solved this problem.  If the analyzer
    Peter> is changed so that it does not return its result back to
    Peter> its caller, then what was called the "Halting Problem" can
    Peter> not occur.  (Show me how it can occur if you disagree).

Feel free to think as if you have done it, although everybody else
(including myself) don't think so, and don't have the slightest worry
that you have done so.

Regards,
Isaac.

Peter Olcott wrote:
> "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m6n1uFjj9mtU1@uni-berlin.de...
>>Peter Olcott wrote:
>>
>>>No Solution to the halting Problem can possibly exist,
>>>It can't exist because Y makes it impossible.
>>>Wait Z can eliminate Y. Once Y is gone, then
>>>the proof by contradiction loses its contradiction.
>>
>>Hmmm... this sounds ok to me.
>>But I've lost in the deluge what Z is.
>>
>>Whatever Z is, is it true, a hypothesis, a change in
>>inference rule, or what?
> 
> LoopIfHalts() is "Y"
> void WillHalt() is "Z".
> 
> Z makes Y impossible to create.
> 
> counter-counter-example.

OK. So to paraphrase in a very liberal-artsy way, only
consider programs that will always halt? (i.e. ensure that Z
is true or something). And then you claim that this makes
the Turing self contradictory construction not possible?
Does that sound about right (with of course leeway for
vagueness)?

-- 
Mitch Harris
(remove q to reply)

 >Peter Olcott wrote:
 >
> All that I need to do is to make the original counter-example
> impossible to create in at least one instance, then I have provided
> the counter-counter-example.

That doesn't sound like good logic. Just fixing one
counterexample does not necessarily preclude other
counterexamples from existing. You'd need to show that there
is no possible way for any counterexample to exist (and
attacking single counterexamples one-by-one is not likely to
be a successful strategy). Of course, to show that the
conclusion of a proof by contradiction is wrong, it would be
silly to attack the proof itself, but to create a new direct
proof (presumably in this case by positive example by giving
a procedure that does decide termination for arbitrary TMs).
And if you assume, as I think you are doing, that the only
TMs you want to consider are already terminating, you have a
trivial proof (no construction needed).

-- 
Mitch Harris
(remove q to reply)

Peter Olcott wrote:
> "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m6ng9Fjjno7U1@uni-berlin.de...
>>Peter Olcott wrote:
>>
>>>I am not nearly as
>>>good with words as I am with logic, that (and/or Groupthink)
>>>is why most people have not yet fully understood what I
>>>am saying.
>>
>>appeal to authority and its varieties is a fallacy that
>>every science is susceptible to. Of all the sciences,
>>mathematics is the least susceptible because everybody has
>>access to the same data, and can do the same experiments to
>>corroborate or falsify. If you want to convince people,
>>citing Groupthink as a parry is not likely to be a succesful
>>strategy.
> 
> Whether it is a successful strategy is not my point.

OK. But I recommend putting your energy into mathematical
reasoning instead of irrelevant philosophical debate.

> I only seek the actual truth, regardless of the consequences.

What other kinds of truth are there? What consequences do
you imagine that you think others are afraid to find out?
This isn't some crime drama.

> It sure looks like GroupThink is operating here.

I agree, to the extent that appeal to the masses and
authority operate in supporting the conjecture that the
square root of 2 is not a rational.

-- 
Mitch Harris
(remove q to reply)

Peter Olcott wrote:
>>All of those kinds of fallacies are fallacious when they are
>>irrelevant to an argument. But they can be very relevant.
> 
> Fallacies are always errors.

Yes, by definition.

An appeal to authority is very relevant when the authority
is an expert in the field in question. In such a case, the
appeal is not a fallacy.

-- 
Mitch Harris
(remove q to reply)

Peter Olcott wrote:
> "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m77adFjrmccU1@uni-berlin.de...
>>Peter Olcott wrote:
 >>
>>>But the Church-Turing thesis says that there can't be a machine
>>>more powerful than a Turing Machine.
>>
>>No, it doesn't. It says that the many formalisms that happen
>>to be just as powerful as a TM are what we should all agree
>>on as the most appropriate formalism in which to discuss
>>computation.
> 
> Turing Thesis (my text gives no credit to Church):
> Any computation that can be carried out by mechanical
> means can be performed by some Turing Machine.
 >
> This seems to agree much more with what I said, than wht you said.

OK. sort of the contrapositive. But it still sounds like a
definition of mechanical or it is a non-mathematical
statement (i.e. a conclusion to be drawn from experience),
rather than a theorem to be proved. What is your text, and
does your text support the idea that the thesis is a theorem
or an observation?

This quote sounds a lot like Thesis M given in:

   http://plato.stanford.edu/entries/church-turing/

(in the section Misunderstandings of the Thesis).

>>this may seem like begging the question to you, since you
>>have not accepted the proof that every one else accepts, but
> 
> It is not merely that I have not accepted a proof that everyone
> else accepts. It is that my disprove of this proof has not yet
> been found in error. If you think that any of the refutations of
> my refutation were valid, then state which one(s).  I have
> found serious flaws in everyone of them.

To the extent that I could understand your refutations (I
had great difficulty), and to the extent that I could then
understand the detractions of these refutations (which I
understood better, because they seemed to accord with my
world view), ... frankly I couldn't understand your
refutations very well. So validity hardly ever entered into
my judgements. I strongly believe that Turing's proof and
theorem are correct, and you say that something about those
two is wrong, so I disagree with you. The things you call
refutations seem to be things I would call modifications.

>>by your previous statement (that adding a "screen" and
>>"protected memory" adds no power, to which I agree) this is
> 
> Not necessarily. The Halting Problem might not be solved
> without them.
> 
>>contradictory. If your proposed machine could solve the
>>Halting problem, then it would be more powerful than your
>>everyday TM. If it is as powerful as TMs, then it cannot
>>solve the Halting problem.

I think you failed to see my point, which was that my
definition of "power of" is "the things that can be solved
by". So, to me, your two statements 1) extra gagets don't
add power 2) extra gadgets help solve a problem unsolvable
without them, are contradictory.

> Protected memory might be construed as beyond the capabilites
> of a TM.

OK. Great. So if you add that capability to a TM then you're 
talking about a machine model that is different from a TM. 
So you either have to show that the additional capability 
doesn't add any power (by reduction to a POTM, plain old TM) 
or by showing that the fancy new TMWPM, TM with protected 
memory, can solve things that a POTM cannot. In the latter 
case (which I think you expect to hold) you're actually 
relying on Turing's (correct) proof that the halting problem 
is unsolvable. Or maybe if you new gadget of protected 
memory is the -only- memory (er... tape) that your TMs have 
then that is a restriction on TMs and so you'd have to show 
that there are some things a POTM can do that your TWWPM 
cannot or give a reduction showing they are of equal power).
"might be construed" translates to "is conjectured to be".

>>I'm sorry but none of this sounds convincing. Not that it is
>>not true, just that they are just simple statements, not
>>even an attempt at convincing.
> 
> It is not meant to be convincing.

Sorry. I was deploring my own statements, not yours.

> Its meant to be a simple statement of
> fact. If you change the form of the WillHalt() function such that its caller
> has no possible access to its result, then the original Halting Problem
> can not possibly be constructed. It really just as simple as that.

OK.

Have you ever seen the movie "Memento"? Have I already asked 
that already?

-- 
Mitch Harris
(remove q to reply)

Isaac To wrote:
>>"Peter" == Peter Olcott <olcott@worldnet.att.net> writes:
> 
>     Peter> Yet can't possibly exist. All this is magic, not computer
>     Peter> science.
> 
> All you can say is that we don't know them exist now, and they don't
> "seem" to exist.  The nature has all kinds of "strange" phenomena that
> nearly everybody other than scientists in physics would call "magic".
> If tomorrow atomic physics researchers tell us that there is a
> physical phenomenon that would solve the halting problem of Turing
> machines I won't be "too" surprised.

Er...I would. Seems very unlikely.

-- 
Mitch Harris
(remove q to reply)

Peter Olcott says...

>> Like I said, Peter. You have no idea what is true, what is
>> false, what is valid and what is fallacious. You are a
>> complete incompetent at logical reasoning. The fact that
>> you *believe* that you haven't been refuted is irrelevant.


>And you can say this with a straight face knowing full well that
>most of what people provided as "refutation" was one fallacy
>or another.

You have been provided with many completely sound proofs
that what you are saying is nonsense. You have been unable
or unwilling to follow any of them. You are incompetent at
logical reasoning, despite your claims to have a genius IQ
and to be a great programmer and inventor and patent holder.

--
Daryl McCullough
Ithaca, NY

Peter Olcott says...

>It ONLY proves that bool WillHalt() does not exist.
>It proves NOTHING about void WillHalt().

There are two possibilities here: (1) Your hypothetical
void WillHalt can be simulated by a Turing Machine, or
(2) It can't.

In case (1), your program has no relevance to
Turing's proof, since he was proving that no *Turing*
machine program  can solve the halting problem. In
case (2), your program fails; it can't solve
the halting problem any better than bool WillHalt() can.

The key point, which I would think you would understand
as a computer programmer, is this:

   If there is a program P1 that sends its outputs to the screen,
   then there is a modified program P2 that returns its outputs
   as a return value.

Exactly *how* you make your outputs is irrelevant.

--
Daryl McCullough
Ithaca, NY

Peter Olcott says...

>"Marc Goodman" <marc.goodman@comcast.net> wrote 

>> Here's a trivial proof:  Your program can model any Turing Machine,
>> so your program is at least as powerful as a Turing Machine.  But no
>> Turing Machine can model your program (otherwise it could simulate
>> your program and return a result, but then it couldn't exist
>> because of the Halting Problem).  So your program must be more
>> powerful than a Turing Machine.  QED.
>>
>
>Turing Thesis:
>Any computation that can be carried out by mechanical means
>can be performed by some Turing Machine.
>
>Hard to see how more powerful than this can exist.

So you are faced with two possibilities: (1) Your program void WillHalt
is more powerful than any Turing machine, and Turing's Thesis is false,
or (2) Your program void WillHalt is no more powerful than a Turing
machine, and therefore, it can't solve the halting problem, either.

Which is it?

--
Daryl McCullough
Ithaca, NY

I am thoroughly confused.  What does micturate have to do with
halting?  Also apostrophes signify either ownership or contraction ...
as in 'the output's incomprehensible' - used for contraction in - 'the
output is incomprehensible' - I see no need for an apostrophe in my
use of the word.

Again, I do not understand what you've written here in response to my
explanation of the halting problem to Peter.  I'm not entirely clear
as to why you've written anything at all.

">parr\(*>" <KurlyGina@tenretnitb.moc> wrote in message news:<cdmlb5$dlb$1@hercules.btinternet.com>...
> Bloody hell!.  I don't understand, Kevin.  Where can I obtain a
> degree in the extraction of micturate such as you clearly must
> posses.
> 
> BTW, to make this comprehensable to Peeter, shouldn't you have spelt
> "outputs" as "output's"?
> --
> )>==ss$$%PARR(�>   Parr
> 
> "Kevin Stern" <K-Stern@neiu.edu> wrote in message
> news:ca77e32d.0407191227.2715e440@posting.google.com...
> | void LoopIfHalts(string SourceCode, string InputData)
> | {
> |   if (WillHalt(SourceCode, InputData) == TRUE)
> |     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
> |

I'm disappointed that you did not respond to the remainder of my post
- that's really where the meat is.  Did you get a chance to read it?

Regarding the response that you did provide:  this is what I said,
sir, I said that you've defined a programming language that allows
only a subset of all possible programs.  In particular, assuming that
Halt(x, y) is recursive, you do not allow the very obviously recursive
program:

Counter{
  if Halt(Counter, '') then Loop
  else stop
}

(if you do allow this program then you would not be saying that Halt
is recursive - because you'd immediately realize that this program,
and this program alone, is enough to show that Halt is not recursive).

You see, in the theory of computing, if Halt is recursive then Counter
is recursive - there is no restriction to this whatsoever.  For a nice
real world example we can think of Virus(x) as a program that looks at
x and determines if it is the encoding of a computer virus.  When
someone comes out with such a program, I'd very much like to add the
following to all of my programs:

ArbitraryProgram {
  If Virus(ArbitraryProgram) then stop
  else ArbitraryProgram();
}

Again, please read my explanation below and see if it makes sense.

"Peter Olcott" <olcott@worldnet.att.net> wrote in message news:<yJDLc.120796$OB3.55058@bgtnsc05-news.ops.worldnet.att.net>...
> > I have read your website and I understand what you are saying.  You
> > are working within a programming language (call it PeterLanguage) that
> > allows only a subset of all possible programs.  You are showing that,
> > perhaps, it is possible to determine whether or not a particular set
> > of programs halt, but your set does not contain all possible programs
> > and the Halting Problem asks in terms of all possible programs.
> > Please let me know if you understand this?
> 
> No this is not quite it.
> I have redefined the Halting analyzer such that the counter-example
> program that shows that solving the Halting Problem is impossible
> can not exist.
> 
> The basic way of doing this is essentially changing the halting analyzer
> from returning Boolean to its caller, to returning nothing to its caller.
> 
> > I've presented the standard recursion theoretic proof of the halting
> > problem below, which I hope will clear things up a bit.  I assume that
> > you've seen Cantor's proof that the Reals are uncountable?  This is a
> > similar diagonalization argument (I will go over it again):
> >
> > We enumerate all possible Turing machine (this can be done because a
> > TM is simply a finite string over a finite alphabet.  These are, now,
> > all possible computer programs - the whole kaboodle:
> >
> >      tm_1 tm_2 tm_3 [...]
> > tm_1   1    0    1  [...]
> > tm_2   0    0    1  [...]
> > tm_3   1    1    0  [...]
> > [...]
> >
> > In addition, (x, y) = 1 if tm_x(tm_y) halts and it is 0 if tm_x(tm_y)
> > does not halt.  Again, these are the only two possibilities, something
> > cannot sort-of halt ... in fact, let's DEFINE 'does not halt' as
> > follows:
> >
> > A TM does not halt if it is not the case that it halts.
> >
> > It should be excrutiatingly clear that a TM either halts or not ...
> >
> > If the halting problem is solvable (as you claim it is), then
> > certainly this program is solvable:
> >
> > D(x) {
> >   if Halt(x, x) = 'No' then Halt
> >   else Loop Forever
> > }
> >
> > Now the question becomes, is this a TM?
> >
> > Well, we have a list of TMs, let's see if it's in the list:
> >
> > Is it TM_1?  Well, it cannot be, because
> >
> > D(TM_1) = if Halt(TM_1, TM_1) = 'No' then Halt else Loop Forever
> >
> > And we can clearly see that TM_1(TM_1) halts (from the graph that I've
> > constructed), so D(TM_1) does not halt.
> >
> > Is it TM_n?  Well, it cannot be, because
> >
> > D(TM_n) = if Halt(TM_n, TM_n) = 'No' then Halt else Loop Forever
> >
> > And we can clearly see that if TM_n(TM_n) halts then D does not halt
> > and if TM_n(TM_n) does not halt then D halts.
> >
> > It, therefore, cannot be any Turing Machines in the list of all Turing
> > Machines.  D is not a Turing Machine and, therefore, Halt is not a
> > Turing Machine.
> >
> > I will try to anticipate your reply (I hope that I am wrong):
> >
> > We cannot compile a program with the line D(TM_n) if we cannot
> > determine whether or not TM_n halts.  This is fine, no problem, REMOVE
> > a finite number of TMs from the list that you don't like ... certainly
> > none of them are the HALT program that you're looking for since you've
> > hand picked them as ones that you don't like because they 'use' the
> > halt program to cause a paradox (in fact you will remove no TMs from
> > the list because there is no Halt program and, therefore, there is no
> > paradox to be caused).  Please, again, let me know if this makes any
> > sense.  Please do not simply write one line and tell me that I am
> > wrong - let me know if you understand my argument and, if not, where
> > it is confusing.  Once you understand my argument then we can talk
> > more about whether or not you've solved the halting problem.
> >
> > Kevin
> >
> > "Peter Olcott" <olcott@worldnet.att.net> wrote in message news:<0eiLc.292197$Gx4.51255@bgtnsc04-news.ops.worldnet.att.net>...
> > > "Kevin Stern" <K-Stern@neiu.edu> wrote in message news:ca77e32d.0407191227.2715e440@posting.google.com...
> > > > void LoopIfHalts(string SourceCode, string InputData)
> > > > {
> > > >   if (WillHalt(SourceCode, InputData) == TRUE)
> > > >     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).
> > >
> > > http://home.att.net/~olcott/halting/example.html
> > > examine this and get back to me
> > >
> > >
> > > > 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" <olcott@worldnet.att.net> wrote in message news:<xCOKc.111569$OB3.81647@bgtnsc05-news.ops.worldnet.att.net>...
> > > > > "Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns952B8AF6F38FCnobodynotmailcom@61.9.191.5...
> > > > > > "Peter Olcott" <olcott@worldnet.att.net> wrote in
> > > > > > news:UHwKc.277072$Gx4.4006@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.
> > > > >
> > > > > > 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.

On 22 Jul 2004 05:17:22 -0700, Daryl McCullough <daryl@atc-nycorp.com>
said:
> Peter Olcott says...
>  
> >It ONLY proves that bool WillHalt() does not exist.
> >It proves NOTHING about void WillHalt().
> 
> There are two possibilities here: (1) Your hypothetical
> void WillHalt can be simulated by a Turing Machine, or
> (2) It can't.
> 
> In case (1), your program has no relevance to
> Turing's proof, since he was proving that no *Turing*
> machine program  can solve the halting problem. In
> case (2), your program fails; it can't solve
> the halting problem any better than bool WillHalt() can.
> 
> The key point, which I would think you would understand
> as a computer programmer, is this:
> 
>    If there is a program P1 that sends its outputs to the screen,
>    then there is a modified program P2 that returns its outputs as a
>    return value.
> 
> Exactly *how* you make your outputs is irrelevant.

I'm *sure* he'll get it this time, Daryl! ;-)

>>>>> "Daryl" == Daryl McCullough <daryl@atc-nycorp.com> writes:

    Daryl> There are two possibilities here: (1) Your hypothetical
    Daryl> void WillHalt can be simulated by a Turing Machine, or (2)
    Daryl> It can't.

    Daryl> In case (1), your program has no relevance to Turing's
    Daryl> proof, since he was proving that no *Turing* machine
    Daryl> program can solve the halting problem. In case (2), your
    Daryl> program fails; it can't solve the halting problem any
    Daryl> better than bool WillHalt() can.

Nope.  If his hypothetical void WillHalt() cannot be simulated by a
Turing Machine (i.e., we cannot show that its power is limited by the
power of a Turing machine), then all bets are off.  Indeed, in that
case even if the function is bool WillHalt(), the proof of the halting
problem breaks down.  The proof says that "there is no Turing machine
capable of solving the halting problem for Turing machines".  It says
nothing about machines that are more capable than Turing machines
(i.e., there might be more powerful machines that solve the halting
problem for Turing machines).  The proof breaks down---since the
Halting solver is more powerful than Turing machines, and because the
Halting solver is only required to take Turing machines (rather than
the stronger machines which the Halting solver is implemented), you
cannot modify it to a Turing machine so as to pass it to the Halting
solver itself.

Of course, in Peter's case, his machine is weaker than a Turing
machine, so your next paragraph still makes perfect sense.

Regards,
Isaac.

Isaac To says...
>
>>>>>> "Daryl" == Daryl McCullough <daryl@atc-nycorp.com> writes:
>
>    Daryl> There are two possibilities here: (1) Your hypothetical
>    Daryl> void WillHalt can be simulated by a Turing Machine, or (2)
>    Daryl> It can't.
>
>    Daryl> In case (1), your program has no relevance to Turing's
>    Daryl> proof, since he was proving that no *Turing* machine
>    Daryl> program can solve the halting problem. In case (2), your
>    Daryl> program fails; it can't solve the halting problem any
>    Daryl> better than bool WillHalt() can.
>
>Nope.  If his hypothetical void WillHalt() cannot be simulated by a
>Turing Machine (i.e., we cannot show that its power is limited by the
>power of a Turing machine), then all bets are off.

Whoops! I got my (1) and (2) mixed up. What I mean to say was that
in case (1) (Peter's program can be simulated by a Turing Machine)
then his program can't solve the halting problem. That follows from
Turing's proof. In case (2) (Peter's program cannot be simulated
by a Turing machine) then his program has no relevance to Turing's
proof, since Turing's proof was about Turing machines.

--
Daryl McCullough
Ithaca, NY



 Indeed, in that
>case even if the function is bool WillHalt(), the proof of the halting
>problem breaks down.  The proof says that "there is no Turing machine
>capable of solving the halting problem for Turing machines".  It says
>nothing about machines that are more capable than Turing machines
>(i.e., there might be more powerful machines that solve the halting
>problem for Turing machines).  The proof breaks down---since the
>Halting solver is more powerful than Turing machines, and because the
>Halting solver is only required to take Turing machines (rather than
>the stronger machines which the Halting solver is implemented), you
>cannot modify it to a Turing machine so as to pass it to the Halting
>solver itself.
>
>Of course, in Peter's case, his machine is weaker than a Turing
>machine, so your next paragraph still makes perfect sense.
>
>Regards,
>Isaac.

Peter Olcott wrote:

>>>If I can provide any means to refute the statement below, I have refuted the HAlting Problem.
>>>No program can ever be written to determine whether any arbitrary program will halt
>>>
>>>It does not matter what you do with this solution, after the fact. It has already
>>>been correctly refuted.
>>
>>1) To refute it, there must be a program that *does* determine if a
>>given program and input results in halting or not halting.
>>2) My understanding of your proposal for the appearance of such a
>>program is outlined above.
>>3) It can be readily modified to the outline below.
>>4) The outline below leads to a contradiction as illustrated in the
>>standard proof that WillHalt() does not exist.
> 
> 
> It ONLY proves that bool WillHalt() does not exist.
> It proves NOTHING about void WillHalt().

1) is based on the claim that bool WillHalt() exists if and only if void 
WillHalt() exists.  I suspect this is the concept you are having trouble 
with.

-- 
Will Twentyman
email: wtwentyman at copper dot net

Peter Olcott wrote:

> Whether it is a successful strategy is not my point.
> I only seek the actual truth, regardless of the consequences.
> It sure looks like GroupThink is operating here.

When you see something that appears to be GroupThink, there are a couple 
of possibilities.  1) Everyone else is unable to think for themselves. 
2) Everyone else understands something that you do not.

Don't be too quick to dismiss 2).

-- 
Will Twentyman
email: wtwentyman at copper dot net

Peter Olcott wrote:

> "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m77adFjrmccU1@uni-berlin.de...
> 
>>Peter Olcott wrote:
>>
>>>"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:x0lLc.131965$%_6.1311@attbi_s01...
>>>
>>>>Peter Olcott wrote:
>>>
>>>But the Church-Turing thesis says that there can't be a machine
>>>more powerful than a Turing Machine.
>>
>>No, it doesn't. It says that the many formalisms that happen
>>to be just as powerful as a TM are what we should all agree
>>on as the most appropriate formalism in which to discuss
>>computation.
> 
> 
> Turing Thesis (my text gives no credit to Church):
> Any computation that can be carried out by mechanical
> means can be performed by some Turing Machine.
> 
> This seems to agree much more with what I said, than wht you said.
> 
> 
>>this may seem like begging the question to you, since you
>>have not accepted the proof that every one else accepts, but
> 
> 
> It is not merely that I have not accepted a proof that everyone
> else accepts. It is that my disprove of this proof has not yet
> been found in error. If you think that any of the refutations of
> my refutation were valid, then state which one(s).  I have
> found serious flaws in everyone of them.

The problem is that your construction is not a disproof, but is 
tangential to the proof you object to.  Your argument simply has no 
impact on the proof.  You have yet to prove that your version of 
WillHalt() exists, only that it is not amenable to the standard 
contradiction if it does exist.


>>If you are saying that your new kind of machine, has
>>particular restrictions, such that there is a procedure
>>(doesn't have to be the same kind of machine, could be a TM
>>or a very lucky geiger counter) to determine if any given
>>machine of your new kind halts or not on given input, well,
>>that's no surprise. There are all sorts of machines for
>>which this is known (some of which have already been
>>mentioned: FSAs, linear bounded automata).
>>
>>I'm sorry but none of this sounds convincing. Not that it is
>>not true, just that they are just simple statements, not
>>even an attempt at convincing.
> 
> 
> It is not meant to be convincing. Its meant to be a simple statement of
> fact. If you change the form of the WillHalt() function such that its caller
> has no possible access to its result, then the original Halting Problem
> can not possibly be constructed. It really just as simple as that.

That fails to prove WillHalt() exists.

-- 
Will Twentyman
email: wtwentyman at copper dot net

Peter Olcott wrote:

>>>But the Church-Turing thesis says that there can't be a machine
>>>more powerful than a Turing Machine. Also adding a screen
>>>and protected memory to a computer does not make it more
>>>powerful, except that this might solve the Halting Problem.
>>
>>Incorrect.  http://en.wikipedia.org/wiki/Oracle_machine  An Oracle
>>machine is a TM with a special oracle function added.  The oracle
>>function can be anything, including WillHalt(), but is generally
>>something that cannot be implemented on a TM.  Such a device is more
>>powerful than a TM.
> 
> Yet can't possibly exist. All this is magic, not computer science.
> At least Turing Machines can mostly exist. No Infinite tape

This is theory.  Lots of things can exist in theory, yet not in reality. 
  Then again, there are now devices that are designed to be true random 
number generators, not pseudo-random number generators.  A random number 
generator that is truly random is one type of oracle.

In reality, I think what you may be attempting to do is create an oracle 
WillHalt() and claim that it is actually a TM WillHalt() without 
realizing it.

-- 
Will Twentyman
email: wtwentyman at copper dot net

Peter Olcott wrote:

> "Will Twentyman" <wtwentyman@read.my.sig> wrote in message news:40fe9674$1_1@newsfeed.slurp.net...
> 
>>Peter Olcott wrote:
>>
>>
>>><stephen@nomail.com> wrote in message news:cdkmm3$1rr5$1@msunews.cl.msu.edu...
>>>
>>>
>>>>In comp.theory Peter Olcott <olcott@worldnet.att.net> wrote:
>>>>
>>>>: So you are saying that a machine that can not be transformed into a
>>>>: Turing Machine, yet can correctly determine whether or not any other
>>>>: software system (including Turing Machines) halts, would not solve
>>>>: the Halting Problem because it is not implemented as a Turing Machine?
>>>>
>>>>The important fact is not that it is not implemented as a Turing Machine,
>>>>but that it *cannot be implemented* as a Turing Machine.   Your last
>>>>phrase should be
>>>>'because it cannot be implemeted as a Turing Machine.'
>>>>
>>>>Stephen
>>>>
>>>
>>>
>>>I don't think that you can find anything anywhere that says that any
>>>solution to the Halting Problem must be limited to a Turing Machine,
>>>otherwise it does not count.
>>
>>No, but it has to be something equivalent to a Turing Machine to count.
>>  For your screen idea to work, it must necessarily not be equivalent to
>>a Turing Machine.
>>
> 
> Another respondent suggested write only memory is the same
> as a screen.

How does that affect my statement?

-- 
Will Twentyman
email: wtwentyman at copper dot net

Peter Olcott wrote:

> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:wSDLc.6249$8_6.1023@attbi_s04...
> 
>>Peter Olcott wrote:
>>
>>>Turing Thesis:
>>>Any computation that can be carried out by mechanical means
>>>can be performed by some Turing Machine.
>>
>>OK, so you are now arguing that your program is not more powerful
>>than a Turing Machine (it either is or it isn't and you just said
>>it isn't).  Therefore your program can be simulated by a Turing
>>Machine that notices when your program hits lines 4, 7 and 10
>>in the program below and returns appropriate values, violating
>>the Halting Problem.  So, you program must either be more powerful
>>than a Turing Machine, which you now deny, or your program cannot
>>exist as detailed explicitly below.  You lose, have a nice day.
>>
> 
> 
> I don't see why everyone here is not getting this:
> Producing a version of WillHalt that does not work
> in no way refutes another version that does work.
> 
> (a) void WillHalt() always works
> (b) bool WillHalt() does not work on some inputs
> 
> From (b) you can conclude nothing at all about (a).

a -> not(b)
b -> not(a)

Regardless of the method of output, it either does or does not work. 
You are focused on output instead of code.

-- 
Will Twentyman
email: wtwentyman at copper dot net

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:N48Lc.115372$OB3.83616@bgtnsc05-news.ops.worldnet.att.net...
|
| ">parr(*>" <KurlyGina@tenretnitb.moc> wrote in message
news:cdh6kq$n7d$1@hercules.btinternet.com...
| > "Peter Olcott" <olcott@worldnet.att.net> wrote in message
| > news:MYGKc.110387$OB3.2183@bgtnsc05-news.ops.worldnet.att.net...
| > | > 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.
| Not at all. What I am saying from a professional programmer
| perspective is that single letter names are bad programming.
| They are not self-documenting.

A professional programmer.


OK

It pleases me to know you realise how important it is to
make things understandable.

But nevertheless, do you understand the content of:
http://www.netaxs.com/people/nerp/automata/halting2.html
?
--
)>==ss$$%PARR(�>   Parr

"Peter Olcott" <olcott@worldnet.att.net> wrote in message news:
> Turing's these says that more powerful that a TM can't exist.

No, it doesn't.  In the first place, it's CHURCH's
Thesis, NOT "Turing's these".   Since you're always
so busy posting links to your OWN crap,why don't you
try posting a link to a correct statement of the
"Church-Turing Thesis" ?   Or not.  My point being
that posting a link to something doesn't prove that
YOU have read what's at the other end of the link, LET ALONE
understood it.

On Thu, 22 Jul 2004 00:05:33 GMT, Peter Olcott <olcott@worldnet.att.net>
said:
>  It is not merely that I have not accepted a proof that everyone
>  else accepts. It is that my disprove of this proof has not yet
>  been found in error. 

Well, golly.  I guess it wasn't clear to me that you thought you'd
"disproved" the proof -- not that it's ever been clear to me what you
think your doing.  Be that as it may, if you've "disproved" the proof,
that means you think that either an invalid inference is made at some
point, or you think one of the premises is false.  So perhaps it will be
useful if you explicitly identify the problem in a very clear and simple
statement of the Halting Problem.  Even if it might be pointless to try
to get you to see that there is no problem, this will at least make it
clear to posterity what it is that you see that everyone else doesn't,
or vice versa.  I've got an hour to kill, so let me join Daryl in the
ranks of second-order crackpottery and try to spell out the argument
carefully.

For simplicity, let's restrict ourselves to the very simple Turing
machines found in the standard text Computability and Logic by Boolos,
Jeffrey, and Burgess.  These machines are capable of being in infinitely
many distinct "states" q_0, q_1, ... (one at a time) and operate on a
tape containing infinitely many "cells" that are either blank or contain
the single symbol X.  (It is easy to show that increasing the number of
symbols does not increase the computational power of Turing machines.)
The "head" of a Turing machine is always located at some cell of the
tape.  Upon reading a cell, a TM can perform one of four actions: (i)
write an X in the cell (whether or not one is already there), (ii)
"write" a blank in the cell (i.e., erase an X or do nothing, if the cell
is blank already), (iii) move left, or (iv) move right.  The behavior of
every Turing machine can then be described by means of a finite set of
instructions of the form <q_n,S,A,q_m>, which means: "If you are in
state q_n and you see S, perform action A and go into state q_m."  Here,
S will be either X or B (representing a blank) and A will be either X,
B, L, or R representing the four actions just noted, respectively.

Note that it is easy to put the class of finite sets of instructions
into a list, and this provides us with an easy way of listing the class
of all TMs.  Thus, every TM can be assigned a unique natural number n
according to its place in the list.  So by "Turing machine n" we mean
the n^th TM in the list of TMs.

Now, in this simple model, we can think of a block of n+1 X's as
representing the natural number n -- in particular, a single X on its
own represents the number 0.  Consider now the following two
definitions:

DEF 1: A Turing machine M *computes* the 1-place function f (from natural
numbers to natural numbers) if and only if, for any natural number n on
which f is defined, when started in state q_0 on the leftmost X of a
block of n+1 X's on an otherwise blank tape, M halts at the leftmost X
of a block of m+1 Xs (on an otherwise blank tape) if and only if f(n) =
m.  If f is undefined on n, then M does not halt when started in the
configuration noted.

DEF 2: A Turing machine M *computes* the 2-place function g if and only
if, for any pair of natural numbers m,n on which g is defined, when
started in state q_0 on the leftmost X of a block of m+1 X's on a tape
containing only that block and another block of n+1 X's to its right,
separated by a single blank cell, M halts at the leftmost X of a block
of r+1 Xs (on an otherwise blank tape) if and only if g(m,n) = r.  If g
is undefined on m,n, then M does not halt when started in the
configuration noted.

Thus, if M* computes, say, the multiplication function, then, when
started on the leftmost X on a tape that looks like this ("B" represents
a blank cell):

                      ...BBBXXXXXXBXXXBBB...

M* will halt on the leftmost X of a tape that looks like this:

                      ...BBBXXXXXXXXXXXBBB...

Now, consider the following definition of the 2-place function Halts on
the natural numbers:

DEF 3:  For natural numbers n,i, Halts(n,i) = 1 if Turing machine n
eventually halts when started in state q_0 at the leftmost X of a block
of i+1 Xs (on an otherwise blank tape), and Halts(n,i) = 0 otherwise,
i.e., if Turing machine n does not eventually halt when started in the
configuration noted.

Note this is just an ordinary, well-defined, 2-place function on the
numbers.  And note that it is a *total* function as well -- it yields
either 1 or 0 for any pair of arguments n,i.  Here, then, is a nice,
simple version of the Halting Problem:  

HP:  To find a Turing machine that computes the function Halts.

And here is an argument that HP is unsolvable, i.e., that there is no
such Turing machine.

Note first that, given Halts, we can define another function Diag in
terms of it:

DEF 4: For any natural number n, Diag(n) = 1 if Halts(n,n) = 0, and
Diag(n) is undefined otherwise.

Again, a perfectly legitimate mathematical function.  Now for the
argument.

1. There is a TM H that computes Halts.  (Assumption for Reductio) 

2. Given the instructions for H, we can easily write a set of
instructions for a TM D that computes the 1-place function Diag.[*] D is
a TM, so it occurs somewhere in our list of all TMs.  So D is Turing
machine n*, for some natural number n*.

3. Either Diag(n*) = 1 or Diag(n*) =/= 1.

4. If Diag(n*) = 1, then, by definition of Diag (DEF 4), Halts(n*,n*) =
0, and hence, by the definition of Halts (DEF 3), Turing machine n*
fails to halt when started in state q_0 on the leftmost X of a block of
n*+1 Xs.  But Turing machine n* is D.  Hence, it is D that fails to halt
when started in the configuration noted.  But D computes Diag, and
hence, since Diag(n*) = 1, by the definition of computation (DEF 1) D
must halt when started in the configuration noted after all.  But we
can't have it both ways.  Hence, it must be false that Diag(n*) = 1.

5. If, on the other hand, Diag(n*) =/= 1, then, by DEF 4 again, Diag(n*)
is undefined.  Hence, since D computes Diag, by DEF 1 again D does not
halt when started on the leftmost X of a block of n*+1 Xs.  By DEF 3,
then, since D is Turing machine n*, Halts(n*,n*) = 0.  But then by DEF 4
again, we have Diag(n*) = 1, after all.  So it's false as well that
Diag(n*) =/= 1.

6. So Diag(n*) can neither be equal to 1 nor not equal to 1, a
contradiction.

7. Hence, our assumption above is false, i.e., there is no TM that 
computes the function Halts, i.e., HP is unsolvable.


Ok, that seems reasonably clear, if somewhat wordier than I'd planned on
when I started.  If you would, then, please "disprove" the proof, i.e.,
identify what you take to be the false premise or the unsound inference.

Chris Menzel

[*]Informally, D will take a block of n+1 Xs, make an adjacent copy, and
then carry out the instructions for H; if that H "subroutine" returns a
single X (i.e., if Halts(n,n) = 0), D will write another X to its left
and halt (i.e., return "1"), otherwise D will loop, e.g., write an X and
erase it over and over, forever.

"Kevin Stern" <K-Stern@neiu.edu> wrote in message news:ca77e32d.0407220430.5cf051f2@posting.google.com...
> I'm disappointed that you did not respond to the remainder of my post
> - that's really where the meat is.  Did you get a chance to read it?
>
> Regarding the response that you did provide:  this is what I said,
> sir, I said that you've defined a programming language that allows
> only a subset of all possible programs.  In particular, assuming that

No. I have defined the solution to the Halting Problem such that
the programs that make a solution impossible aren't possible.
This includes any program that tests the return value of Halt().

> Halt(x, y) is recursive, you do not allow the very obviously recursive
> program:
>
> Counter{
>   if Halt(Counter, '') then Loop
>   else stop
> }

> To the extent that I could understand your refutations (I
> had great difficulty), and to the extent that I could then
> understand the detractions of these refutations (which I
> understood better, because they seemed to accord with my
> world view), ... frankly I couldn't understand your
> refutations very well. So validity hardly ever entered into
> my judgements.

I merely redefined the halt analyzer such that the means to
prove that a solution to the Halting Problem can not exist,
can not exist.

> I strongly believe that Turing's proof and
> theorem are correct, and you say that something about those

Ah so you have bias!

> two is wrong, so I disagree with you. The things you call
> refutations seem to be things I would call modifications.

Fine I modified the Halt analyzer so that universal detection
of halting is possible. Yet since the original proof claimed
that this is impossible, this is also a refutation.

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

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m9ds5Fkr9m4U1@uni-berlin.de...
> Peter Olcott wrote:
> >>All of those kinds of fallacies are fallacious when they are
> >>irrelevant to an argument. But they can be very relevant.
> >
> > Fallacies are always errors.
>
> Yes, by definition.
>
> An appeal to authority is very relevant when the authority
> is an expert in the field in question. In such a case, the
> appeal is not a fallacy.
>
> -- 
> Mitch Harris
> (remove q to reply)
>

In deductive logic, it is always an error.
It becomes valid in inductive logic.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m9cgjFkj9b4U1@uni-berlin.de...
> >Peter Olcott wrote:
>  >
> > All that I need to do is to make the original counter-example
> > impossible to create in at least one instance, then I have provided
> > the counter-counter-example.
>
> That doesn't sound like good logic. Just fixing one
> counterexample does not necessarily preclude other
> counterexamples from existing.

This is not required. My goal is to merely correctly refute
the original proof. I did that.

> You'd need to show that there
> is no possible way for any counterexample to exist (and
> attacking single counterexamples one-by-one is not likely to
> be a successful strategy). Of course, to show that the
> conclusion of a proof by contradiction is wrong, it would be
> silly to attack the proof itself, but to create a new direct
> proof (presumably in this case by positive example by giving
> a procedure that does decide termination for arbitrary TMs).
> And if you assume, as I think you are doing, that the only
> TMs you want to consider are already terminating, you have a
> trivial proof (no construction needed).
>
> -- 
> Mitch Harris
> (remove q to reply)
>

"Peter Olcott" <olcott@worldnet.att.net> wrote in 
news:IZXLc.305676$Gx4.108138@bgtnsc04-news.ops.worldnet.att.net:

> I merely redefined the halt analyzer such that the means to
> prove that a solution to the Halting Problem can not exist,
> can not exist.
> 

But the means by which a solution to halting problem has been proved not to 
exist is logical argument.  Do you really wish to imply that your argument 
makes logic impossible?


-- 
CodeCutter - good, fast and cheap; pick two.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m9b89Fkj9ulU1@uni-berlin.de...
> Peter Olcott wrote:
> > "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m6n1uFjj9mtU1@uni-berlin.de...
> >>Peter Olcott wrote:
> >>
> >>>No Solution to the halting Problem can possibly exist,
> >>>It can't exist because Y makes it impossible.
> >>>Wait Z can eliminate Y. Once Y is gone, then
> >>>the proof by contradiction loses its contradiction.
> >>
> >>Hmmm... this sounds ok to me.
> >>But I've lost in the deluge what Z is.
> >>
> >>Whatever Z is, is it true, a hypothesis, a change in
> >>inference rule, or what?
> >
> > LoopIfHalts() is "Y"
> > void WillHalt() is "Z".
> >
> > Z makes Y impossible to create.
> >
> > counter-counter-example.
>
> OK. So to paraphrase in a very liberal-artsy way, only
> consider programs that will always halt? (i.e. ensure that Z
> is true or something). And then you claim that this makes
> the Turing self contradictory construction not possible?
> Does that sound about right (with of course leeway for
> vagueness)?
>
> -- 
> Mitch Harris
> (remove q to reply)
>
No!   Consider all programs that can possibly exist.
Make original counter-example program impossible
to exist, relative to the solved Halting Problem. It can
still exist. It can still have access to the return results
of another corrupted version of WillHalt(). My uncorrupted
version will correctly determine halting in all cases.

> >>Which did you have wrong Peter, the valid reasoning or the true
> >>premises?
> >>

I have nothing wrong. Some "experts" here don't even
know the very first thing about correct reasoning. Not
even the very first thing.

> >
> > Several people here openly laughed at me for saying that
> > a sound argument required both true premises and valid
> > reasoning. They thought that the idea of true premises was
> > absurd. Amazingly enough they were not kidding, they
> > really thought that all reasoning only starts with arbitrary
> > assumptions.
>
> This in no way answers the above question.  Here it is stated
> more simply: Were you wrong that your program was not limited
> to Turing machines, or were you wrong that any computation
> that can be carried out by mechanical means can be performed
> by some Turing machine, or were you wrong that your program
> works.  It has to be one or the other.  Lucky you, you get
> to pick exactly which mistake you made, and we'll proceed from
> there.
>

"Peter Olcott" <olcott@worldnet.att.net> wrote in 
news:DdYLc.305754$Gx4.53183@bgtnsc04-news.ops.worldnet.att.net:

> I have nothing wrong. Some "experts" here don't even
> know the very first thing about correct reasoning. Not
> even the very first thing.
> 

I'm sure that's true.  I myself do not know the very first thing about 
correct reasoning.  What is it?  What is the primary fact about correct 
reasoning?



-- 
CodeCutter - good, fast and cheap; pick two.

On Thu, 22 Jul 2004 02:08:25 +0000, Peter Olcott wrote:


> "Isaac To" <isaact@netscape.net> wrote in message
> news:87iscgzv0f.fsf@sinken.local.csis.hku.hk...
>> >>>>> "Peter" == Peter Olcott <olcott@worldnet.att.net> writes:
>>
>>     Peter> Yet can't possibly exist. All this is magic, not computer
>>     Peter> science.
>>
>> All you can say is that we don't know them exist now, and they don't
>> "seem" to exist.  The nature has all kinds of "strange" phenomena that
>> nearly everybody other than scientists in physics would call "magic".
>> If tomorrow atomic physics researchers tell us that there is a physical
>> phenomenon that would solve the halting problem of Turing machines I
>> won't be "too" surprised.
>>
>> Regards,
>> Isaac.
> 
> But, I have already solved this problem. If the analyzer is changed so
> that it does not return its result back to its caller, then what was
> called the "Halting Problem" can not occur.  (Show me how it can occur
> if you disagree).

The problem with this concept is that the analyzer you're modifying so it
doesn't return it's result doesn't happen to exist.  You've started from a
false premise.  Starting from a false premise is fine if what you're
trying to prove is the falseness of the premise - that's proof by
contradiction.  It doesn't work if you're trying to prove something
dependent on the truth of the premise.

The analyzer you're claiming to modify to debunk the proof was proven not
to exist by the proof you're trying to debunk.

Peter Olcott wrote:
>>This in no way answers the above question.  Here it is stated
>>more simply: Were you wrong that your program was not limited
>>to Turing machines, or were you wrong that any computation
>>that can be carried out by mechanical means can be performed
>>by some Turing machine, or were you wrong that your program
>>works.  It has to be one or the other.  Lucky you, you get
>>to pick exactly which mistake you made, and we'll proceed from
>>there.

Since you've chosen to ignore the question once again,
here it is repeated in all its glory.  I eagerly
await a response the third time around.

Peter Olcott <olcott@worldnet.att.net> wrote:
>  No. I have defined the solution to the Halting Problem such that
>  the programs that make a solution impossible aren't possible.
>  This includes any program that tests the return value of Halt().

OK. Let's assume that Halt's return value may not be tested. What does
that prove?
It only proves that the standard proof that the halting problem cannot
be solved cannot be used to attack your program. That does not mean that
there is no proof at all that can be used to attack your program; and it
most certainly does not mean that you have solved the halting problem
just because the standard proof doesn't work.
You are essentially saying this: "If we disregard Turing's rules of how
Turing machines work, his proof cannot be applied." Well, big deal. How
does that solve the halting problem?

BTW, ist first-order logic decidable in your universe?


Gergo (de-lurking)
-- 
Chicken Little was right.

Peter Olcott (PO) wrote:

  PO> Method of this Proof
  PO> X = The solution to the Halting Problem
  PO> Y = The basis of the original proof
  PO> Z = The basis of this proof

  PO> Structure of Original Proof---->Y makes X impossible

That is not the structure of the Original Proof. It rather is:

     If X is possible, then we can construct Y (via small
     modifications that are easily verified to be correct). However, Y
     leads to a contradiction, and is therefore impossible. Since the
     steps to modify X into Y are valid, the conclusion is that X is
     impossible.

     There is a fundamental difference between stating "Y exists and
     makes X impossible" and "_If_ X exists, _then_ Y exists, but Y
     makes X impossible". Turing's proof does _not_ state that Y
     exists.

  PO> Structure of This Proof--------->Z makes Y impossible

     Y is impossible indeed (and again, since the steps to go from X
     to Y are clearly valid, the reason that Y is impossible is that X
     is impossible). Now since Y is already impossible, it is not a
     surprise that from Y one can derive other constructs (such as
     your Z) that also show that Y is impossible. That doesn't
     contradict the fact that X is impossible at all.

Best,
Ren� 

Peter Olcott wrote:

> No!   Consider all programs that can possibly exist.
> Make original counter-example program impossible
> to exist, relative to the solved Halting Problem. It can
> still exist. It can still have access to the return results
> of another corrupted version of WillHalt(). My uncorrupted
> version will correctly determine halting in all cases.

Let me state, in yet another different way, why your "void
WillHalt(P,q)" function cannot exist. I will number the
sentences, so that you can easily specify which statement you
don't agree with.

[1] In order to create "void WillHalt" you need code to decide
the halting problem.

[2] Turing proved that this code cannot exist.

[3] Since your function depends on this code, it cannot exist.

Which sentence do you not agree with?

This is what you do: you take code, which provably does not
exist, add a security mechanism, and claim that suddenly the
code does exist.

It's analagous to the following argument: "It is not true
that square circles don't exist, because we can put one in a
safe so that nobody can see it anymore."

groente
-- Sander

I was perusing some of the other posts and I see that it seems
impossible to communicate with you.  Without addressing right vs.
wrong, we seem to have such profoundly different logic systems under
which we operate.  To give an obvious example:

What I said:
> > sir, I said that you've defined a programming language that allows
> > only a subset of all possible programs.  In particular, assuming that

What you said:

> No. I have defined the solution to the Halting Problem such that
> the programs that make a solution impossible aren't possible.

I really have no methods in my mental arsenal to attack the problems
that we've enountered ... you see, I see myself having said that you
are not allowing all possible programs (or, rather, you are allowing
only a subset of all possible programs) and I see your response in the
negative ... asserting, that I am NOT correct.  The shocking thing is
that you go on to say that you're only allowing a subset of all
possible programs.

Good luck!

"Peter Olcott" <olcott@worldnet.att.net> wrote in message news:<NRXLc.305638$Gx4.149317@bgtnsc04-news.ops.worldnet.att.net>...
> "Kevin Stern" <K-Stern@neiu.edu> wrote in message news:ca77e32d.0407220430.5cf051f2@posting.google.com...
> > I'm disappointed that you did not respond to the remainder of my post
> > - that's really where the meat is.  Did you get a chance to read it?
> >
> > Regarding the response that you did provide:  this is what I said,
> > sir, I said that you've defined a programming language that allows
> > only a subset of all possible programs.  In particular, assuming that
> 
> No. I have defined the solution to the Halting Problem such that
> the programs that make a solution impossible aren't possible.
> This includes any program that tests the return value of Halt().
> 
> > Halt(x, y) is recursive, you do not allow the very obviously recursive
> > program:
> >
> > Counter{
> >   if Halt(Counter, '') then Loop
> >   else stop
> > }

Peter Olcott wrote:
> "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m9b89Fkj9ulU1@uni-berlin.de...
 >
>>OK. So to paraphrase in a very liberal-artsy way, only
>>consider programs that will always halt? (i.e. ensure that Z
>>is true or something). And then you claim that this makes
>>the Turing self contradictory construction not possible?
>>Does that sound about right (with of course leeway for
>>vagueness)?
> 
> No!   Consider all programs that can possibly exist.

OK. All TMs.

> Make original counter-example program impossible
> to exist, relative to the solved Halting Problem. 

Er.. not OK.

- what I consider to be the original counter-example program
already doesn't exist. I think the name we've given it here
is not appropriate. Turing constructed a TM, using a TM that
hypothetically already solves the Halting problem. This
construction (what I think we are calling "the counter
example") is contradictory and so at least one of the
hypotheses is wrong, and we choose the existence of a TM for
the Halting Problem to be the wrong one.

> It can still exist. 

You confuse me terribly. You just said make it impossible to 
exist (even though it already doesn't exist), and now you 
say it exists. Are you changing "it"'s?

> It can still have access to the return results
> of another corrupted version of WillHalt(). My uncorrupted
> version will correctly determine halting in all cases.

As many people have already told you (and each of those many
people have often told you), this is just a different
construction, it doesn't invalidate Turing's construction.

-- 
Mitch Harris
(remove q to reply)

Peter Olcott wrote:
> "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m9cgjFkj9b4U1@uni-berlin.de...
>>>Peter Olcott wrote:
>>
>>>All that I need to do is to make the original counter-example
>>>impossible to create in at least one instance, then I have provided
>>>the counter-counter-example.
>>
>>That doesn't sound like good logic. Just fixing one
>>counterexample does not necessarily preclude other
>>counterexamples from existing.
> 
> This is not required. 

Er... yes it is. To prove: not forall x P(x), one can prove
exists x not P(x). for the latter one may produce the thing
c, called a counterexample, such that not P(c). Suppose one
finds a flaw in the justification that not P(c) is true. I
think you are claiming to have done this. But your claim
(true or not) does not (necessarily!) prevent another
element d from existing such that not P(d).

I'm not sure either of us is saying relevant things at this
point though.

> My goal is to merely correctly refute the original proof. 

OK.

 > I did that.

I disagree.

-- 
Mitch Harris
(remove q to reply)

Will Twentyman wrote:
> Peter Olcott wrote:
> 
>> Whether it is a successful strategy is not my point.
>> I only seek the actual truth, regardless of the consequences.
>> It sure looks like GroupThink is operating here.
> 
> When you see something that appears to be GroupThink, there are a couple 
> of possibilities.  1) Everyone else is unable to think for themselves. 
> 2) Everyone else understands something that you do not.
> 
> Don't be too quick to dismiss 2).

Ya know, all along the way, this experience has taught me 
that there doesn't seem to be any reason to accept 2) at 
all. That is (so that people don't think I am being ...uh...
(I can't think of any words both appropriate and polite!) 
How can one convince someone else of the reasonableness of 
2)? (that is without making everybody's arguments equally valid)

-- 
Mitch Harris
(remove q to reply)

Peter Olcott wrote:
> "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m9ds5Fkr9m4U1@uni-berlin.de...
> 
>>Peter Olcott wrote:
>>
>>>>All of those kinds of fallacies are fallacious when they are
>>>>irrelevant to an argument. But they can be very relevant.
>>>
>>>Fallacies are always errors.
>>
>>Yes, by definition.
>>
>>An appeal to authority is very relevant when the authority
>>is an expert in the field in question. In such a case, the
>>appeal is not a fallacy.
> 
> In deductive logic, it is always an error.
> It becomes valid in inductive logic.

OK. I'll accept that. That's a very reasonable distinction.

-- 
Mitch Harris
(remove q to reply)

Peter Olcott wrote:
>>To the extent that I could understand your refutations (I
>>had great difficulty), and to the extent that I could then
>>understand the detractions of these refutations (which I
>>understood better, because they seemed to accord with my
>>world view), ... frankly I couldn't understand your
>>refutations very well. So validity hardly ever entered into
>>my judgements.
> 
> I merely redefined the halt analyzer such that the means to
> prove that a solution to the Halting Problem can not exist,
> can not exist.

halt -analyzer-? What the heck is that? Is that the 
-assumption- of a solution to the Halting Problem?

>>I strongly believe that Turing's proof and
>>theorem are correct, and you say that something about those
> 
> Ah so you have bias!

Well, duh! As much as -you- do to -your- beliefs. (I'm sure 
there's some sort of Smullyan thingy about to pop out of 
this about believing in your beliefs and such. maybe it's 
that of the beielfs that I old, I actually know them to be 
true, except that I may be wrong. Something like that. Good 
times that.)

I was just telling you my beliefs in order to

- be open to you about which side I'm trying to support, no
matter how many levels of skepticism we pursue.

- not be too dogmatic. maybe I'm wrong. (I don't believe it
though!)

>>two is wrong, so I disagree with you. The things you call
>>refutations seem to be things I would call modifications.
> 
> Fine I modified the Halt analyzer so that universal detection
> of halting is possible. Yet since the original proof claimed
> that this is impossible, this is also a refutation.

Hmm.. so this corroborates many ancient observations about 
your position (which you have either denied or ignored).

-modify- the -Halt analyzer- making -halt solving possible-
    |              |                        |
    |              |                        |
    |              |                        v
    |              |          original proof shows impossible
    |              |
    |              |
    |              v
    |          hypothetically exists
    |          assumption introduced for the
    |          purposes of proof by contradiction
    |
    |
    v
  changes the problem so that
  the new proof applies to a
  different situation

So I think we're all only equal footing now. On both sides I
think we can say we have denied or ignored the others'
arguments. Anybody, is that reasonable? (I don't think so, 
but I can't articulate why.)

-- 
Mitch Harris
(remove q to reply)

On Fri, 23 Jul 2004, Mitch Harris wrote:
>
> Peter Olcott wrote:
>> Ah so you have bias!
>
> Well, duh! As much as -you- do to -your- beliefs. (I'm sure there's some
> sort of Smullyan thingy about to pop out of this about believing in your
> beliefs and such. maybe it's that of the beielfs that I old, I actually
> know them to be true, except that I may be wrong. Something like that.
> Good times that.)

   Peter's humorless attitude has already given rise to several
situations very similar to one of Smullyan's "Ways To Prove
Anything."

     Alice: Santa Claus exists, if I am not mistaken.
     Bob: Well, of course Santa Claus exists, *IF* you are not mistaken!
     Alice: So I was *NOT* mistaken --- and therefore, by your own
       admission, Santa Claus must exist!

Same situation here, except that Peter's Santa Claus is some kind
of super-Turing-machine computing device.

[snip]
> - not be too dogmatic. maybe I'm wrong. (I don't believe it
> though!)

   Alice: Ah, so you say something you don't believe!  That makes
      you not only prejudiced, but a hypocrite to boot!
:)

> So I think we're all only equal footing now. On both sides I
> think we can say we have denied or ignored the others'
> arguments. Anybody, is that reasonable?

   Well, if you hadn't denied his argument, you'd have agreed with
it, correct?  And since his argument is false, it would have been
a bad thing /not/ to deny it, wouldn't it?  So don't feel too bad
about it.  Yer still a hypocrite, though. ;))

-Arthur

   Incidentally, I wish everybody here were less cynical.  If that
were the case, you all could have stopped responding once Peter
admitted he had been wrong all along, and it would have returned
to normal in comp.theory.  Instead, some blasted cynic had to take
a look at the path of that message, and now we're all back to kook-
baiting.  Just couldn't take it at face value, could you? :)

Will Twentyman <wtwentyman@read.my.sig> writes:
 : >>Incorrect.  http://en.wikipedia.org/wiki/Oracle_machine  An Oracle
 : >>machine is a TM with a special oracle function added.  The oracle
 : >>function can be anything, including WillHalt(), but is generally
 : >>something that cannot be implemented on a TM.  Such a device is more
 : >>powerful than a TM.

I think *I* said "oracle" first.

PO:
 : > Yet can't possibly exist. All this is magic, not computer science.
 : > At least Turing Machines can mostly exist. No Infinite tape

But PO couldn't be bothered to engage even THAT much, back when I said 
it, EVEN though I said it attempting to defend HIM, intellectually.
 

WT:
 : In reality, I think what you may be attempting to do is create an
 : oracle WillHalt() and claim that it is actually a TM WillHalt()
 : without realizing it.

If it's an oracle then precisely as he said,
it's "magic, not computer science", so it's not what
we was trying to "create".  He was, however, trying to rely on
it, in some sense.  OUR whole point is that if you are going
to discuss WillHalt at all (REGARDLESS of how it was "created"),
you're going to HAVE to be doing "magic, not computer science",
because "computer science" (up to the limit of Church's
Thesis, anyway) has already been PROVEN to be INadequate to the
WillHalt task.

PO also said something relevant about having "proven the point of the
logical positivists" by acting as though anything that was logically
consistent really did exist.   Logical postivism notwithstanding,
classical FOL does have both a completeness theorem and a model
existence theorem, which conjointly do sort of say exactly that.
-- 
 --- 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

"Peter Olcott" <olcott@worldnet.att.net> writes:
 : Turing Thesis:
 : Any computation that can be carried out by mechanical means
 : can be performed by some Turing Machine.

Cite a link to academic research alleging that THIS is the
content of "the Turig Thesis".
-- 
 --- 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

"Kevin Stern" <K-Stern@neiu.edu> wrote in message news:ca77e32d.0407230355.22ca5abb@posting.google.com...
> I was perusing some of the other posts and I see that it seems
> impossible to communicate with you.  Without addressing right vs.
> wrong, we seem to have such profoundly different logic systems under
> which we operate.  To give an obvious example:
>
> What I said:
> > > sir, I said that you've defined a programming language that allows
> > > only a subset of all possible programs.  In particular, assuming that
>
> What you said:
>
> > No. I have defined the solution to the Halting Problem such that
> > the programs that make a solution impossible aren't possible.
>
> I really have no methods in my mental arsenal to attack the problems
> that we've enountered ... you see, I see myself having said that you
> are not allowing all possible programs (or, rather, you are allowing
> only a subset of all possible programs)  and I see your response in the
> negative ... asserting, that I am NOT correct.  The shocking thing is
> that you go on to say that you're only allowing a subset of all
> possible programs.

My idea works for the universal set of all possible programs.
This is a true fact. There is no loophole around it.

In article <2mcg8kFl1u30U1@uni-berlin.de>,
 Mitch Harris <harrisq@tcs.inf.tu-dresden.de> wrote:

>Will Twentyman wrote:
>> Peter Olcott wrote:
>> 
>>> Whether it is a successful strategy is not my point.
>>> I only seek the actual truth, regardless of the consequences.
>>> It sure looks like GroupThink is operating here.
>> 
>> When you see something that appears to be GroupThink, there are a couple 
>> of possibilities.  1) Everyone else is unable to think for themselves. 
>> 2) Everyone else understands something that you do not.
>> 
>> Don't be too quick to dismiss 2).
>
>Ya know, all along the way, this experience has taught me 
>that there doesn't seem to be any reason to accept 2) at 
>all. That is (so that people don't think I am being ...uh...
>(I can't think of any words both appropriate and polite!) 
>How can one convince someone else of the reasonableness of 
>2)? (that is without making everybody's arguments equally valid)

Clearly, one cannot convince an adamant believer in (1) of _anything_ 
that they'd rather not believe, since any such attempt can be dismissed 
by (1) as being an instance of the general vast ignorance / conspiracy / 
whatever.

For example, a fundamentalist Freudian can dismiss any argument against 
the Master's teachings by claiming that it's the product of denial, 
repression, etc.

Similarly, paranoia is logically defensible: "they" may indeed be out to 
get you, and the whole apparent universe (including the apparent 
implausibility of the existence of "them") could be "their" elaborate 
deception.

-- 
---------------------------
|  BBB                b    \     Barbara at LivingHistory stop co stop uk
|  B  B   aa     rrr  b     |
|  BBB   a  a   r     bbb   |   
|  B  B  a  a   r     b  b  |   
|  BBB    aa a  r     bbb   |   
-----------------------------

Peter Olcott wrote:
> My idea works for the universal set of all possible programs.
> This is a true fact. There is no loophole around it.

Except that we've proven your program doesn't exist and you've
never refuted that.

"Ren� van Oostrum" <rene+gnus@cs.uu.nl> wrote in message news:vlacxrqcn3.fsf@hapert.cs.uu.nl...
> Peter Olcott (PO) wrote:
>
>   PO> Method of this Proof
>   PO> X = The solution to the Halting Problem
>   PO> Y = The basis of the original proof
>   PO> Z = The basis of this proof
>
>   PO> Structure of Original Proof---->Y makes X impossible
>
> That is not the structure of the Original Proof. It rather is:
>
>      If X is possible, then we can construct Y (via small
>      modifications that are easily verified to be correct). However, Y
>      leads to a contradiction, and is therefore impossible. Since the
>      steps to modify X into Y are valid, the conclusion is that X is
>      impossible.
>
>      There is a fundamental difference between stating "Y exists and
>      makes X impossible" and "_If_ X exists, _then_ Y exists, but Y
>      makes X impossible". Turing's proof does _not_ state that Y
>      exists.
>
>   PO> Structure of This Proof--------->Z makes Y impossible
>
>      Y is impossible indeed (and again, since the steps to go from X
>      to Y are clearly valid, the reason that Y is impossible is that X
>      is impossible). Now since Y is already impossible, it is not a
>      surprise that from Y one can derive other constructs (such as
>      your Z) that also show that Y is impossible. That doesn't
>      contradict the fact that X is impossible at all.
>
> Best,
> Ren�
>

All that Turing's proof showed was that you can not construct a halt
analyzer that returns its result back to the program being analyzed.
This has been taken to mean (but does not mean) that

No program can ever be written to determine whether
any arbitrary program will halt.

If the only possible way to construct a halt analyzer always
required that the result must be returned to the program
being analyzed, then Turing's proof would have been correct.
Since it is possible to create a halt analyzer that does not
return its result back to the program being analyzed, then
Turing proof is not correct. It is as simple as that.

"Gergo Barany" <gergo@tud.at> wrote in message news:slrncg1n3k.ppl.gergo@hold.otthon.at...
> Peter Olcott <olcott@worldnet.att.net> wrote:
> >  No. I have defined the solution to the Halting Problem such that
> >  the programs that make a solution impossible aren't possible.
> >  This includes any program that tests the return value of Halt().
>
> OK. Let's assume that Halt's return value may not be tested. What does
> that prove?

It proves that the following statement is not proven to be true:
No program can ever be written to determine whether any
arbitrary program will halt

> It only proves that the standard proof that the halting problem cannot
> be solved cannot be used to attack your program. That does not mean that
> there is no proof at all that can be used to attack your program; and it
> most certainly does not mean that you have solved the halting problem
> just because the standard proof doesn't work.

It means that I have correctly refuted the original proof that the problem
can not possibly be solved.

> You are essentially saying this: "If we disregard Turing's rules of how
> Turing machines work,

Not at all. All that we have to do is to see that there is more than one
possible way to construct a halt analyzer. It is not a logical necessity
to return the result of the halt analyzer to its caller. If this is the only
possible way to construct a halt analyzer, then Turing's proof would have
been correct. Since this is not the only possible way to construct
a halt analyzer, Turing's proof is incorrect.

> his proof cannot be applied." Well, big deal. How
> does that solve the halting problem?

It only solves the problem in the sense that the original proof's
statement that solving this problem is impossible, is incorrect.

>
> BTW, ist first-order logic decidable in your universe?
>
>
> Gergo (de-lurking)
> -- 
> Chicken Little was right.

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:GrjMc.173166$XM6.124562@attbi_s53...
> Peter Olcott wrote:
> > My idea works for the universal set of all possible programs.
> > This is a true fact. There is no loophole around it.
>
> Except that we've proven your program doesn't exist and you've
> never refuted that.
>

All that I have conclusively proven is that the original proof that:

No program can ever be written to determine whether any
arbitrary program will halt

is incorrect.

> >>An appeal to authority is very relevant when the authority
> >>is an expert in the field in question. In such a case, the
> >>appeal is not a fallacy.
> >
> > In deductive logic, it is always an error.
> > It becomes valid in inductive logic.
>
> OK. I'll accept that. That's a very reasonable distinction.
>
> -- 
> Mitch Harris
> (remove q to reply)
>
It's just the facts.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2mcfuaFkaq8kU1@uni-berlin.de...
> Peter Olcott wrote:
> > "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m9cgjFkj9b4U1@uni-berlin.de...
> >>>Peter Olcott wrote:
> >>
> >>>All that I need to do is to make the original counter-example
> >>>impossible to create in at least one instance, then I have provided
> >>>the counter-counter-example.
> >>
> >>That doesn't sound like good logic. Just fixing one
> >>counterexample does not necessarily preclude other
> >>counterexamples from existing.
> >
> > This is not required.


It is not my goal to prove this statement true:
A program can definitely be  written to determine whether any arbitrary
program will halt

My only goal is to show that the proof of this statement:
No program can ever be written to determine whether any arbitrary
program will halt

is incorrect.



> Er... yes it is. To prove: not forall x P(x), one can prove
> exists x not P(x). for the latter one may produce the thing
> c, called a counterexample, such that not P(c). Suppose one
> finds a flaw in the justification that not P(c) is true. I
> think you are claiming to have done this. But your claim
> (true or not) does not (necessarily!) prevent another
> element d from existing such that not P(d).
>
> I'm not sure either of us is saying relevant things at this
> point though.
>
> > My goal is to merely correctly refute the original proof.
>
> OK.
>
>  > I did that.
>
> I disagree.
>
> -- 
> Mitch Harris
> (remove q to reply)
>

> - what I consider to be the original counter-example program
> already doesn't exist. I think the name we've given it here
> is not appropriate. Turing constructed a TM, using a TM that
> hypothetically already solves the Halting problem. This
> construction (what I think we are calling "the counter
> example") is contradictory and so at least one of the
> hypotheses is wrong, and we choose the existence of a TM for
> the Halting Problem to be the wrong one.

Yes, at least one of the assumptions is wrong. What about the
assumption that you must return that result of the halt analysis
back to the program being analyzed?

http://home.att.net/~olcott/halting/example.html
Let's use the terminology of this link for our basis.
All of these programs can exist.

> > It can still exist.
>
> You confuse me terribly. You just said make it impossible to
> exist (even though it already doesn't exist), and now you
> say it exists. Are you changing "it"'s?
>
> > It can still have access to the return results
> > of another corrupted version of WillHalt(). My uncorrupted
> > version will correctly determine halting in all cases.
>
> As many people have already told you (and each of those many
> people have often told you), this is just a different
> construction, it doesn't invalidate Turing's construction.
>
> -- 
> Mitch Harris
> (remove q to reply)
>

> Let me state, in yet another different way, why your "void
> WillHalt(P,q)" function cannot exist. I will number the
> sentences, so that you can easily specify which statement you
> don't agree with.
>
> [1] In order to create "void WillHalt" you need code to decide
> the halting problem.
>
> [2] Turing proved that this code cannot exist.

Turing only proved that bool WillHalt() can not exist. He proved nothing
at all about void WillHalt(). It is possible to construct a halt analyzer that
does not return its result back to the program being analyzed. When this
result is returned back to the program being analyzed, this result changes
the behavior of the program being analyzed, and thus the resulting halt
analysis varies depending upon whether the result is returned back to the
program being analyzed or not.

> [3] Since your function depends on this code, it cannot exist.
>
> Which sentence do you not agree with?
>
> This is what you do: you take code, which provably does not
> exist, add a security mechanism, and claim that suddenly the
> code does exist.
>
> It's analagous to the following argument: "It is not true
> that square circles don't exist, because we can put one in a
> safe so that nobody can see it anymore."
>
> groente
> -- Sander
>

> > But, I have already solved this problem. If the analyzer is changed so
> > that it does not return its result back to its caller, then what was
> > called the "Halting Problem" can not occur.  (Show me how it can occur
> > if you disagree).
>
> The problem with this concept is that the analyzer you're modifying so it
> doesn't return it's result doesn't happen to exist.  You've started from a

I asked you to show me how it can occur if your disagree. You are not
showing me how it can occur. You are merely claiming without supporting
the claim. You are beginning with one assumption, and deriving another
assumption from it.

Show me via a detailed execution trace of exactly why my reasoning is
incorrect. Point me to the exect line number where my reasoning fails.

> false premise.  Starting from a false premise is fine if what you're
> trying to prove is the falseness of the premise - that's proof by
> contradiction.  It doesn't work if you're trying to prove something
> dependent on the truth of the premise.
>
> The analyzer you're claiming to modify to debunk the proof was proven not
> to exist by the proof you're trying to debunk.
>
>
>

"Peter Olcott" <olcott@worldnet.att.net> wrote in 
news:YflMc.129177$OB3.119435@bgtnsc05-news.ops.worldnet.att.net:

> Yes, at least one of the assumptions is wrong. What about the
> assumption that you must return that result of the halt analysis
> back to the program being analyzed?
> 

Yes, that's a terrible assumption to make about a function that is defined 
to return the result of the halt analysis back to the function that called 
for the result.


-- 
CodeCutter - good, fast and cheap; pick two.

On Sat, 24 Jul 2004 03:52:27 GMT, Peter Olcott <olcott@worldnet.att.net> said:
> ..
> All that I have conclusively proven is that the original proof that:
> 
> No program can ever be written to determine whether any
> arbitrary program will halt
> 
> is incorrect.

A sad joke.  You don't even understand the problem, let alone the basic
mathematics behind.

On Sat, 24 Jul 2004 03:42:21 GMT, Peter Olcott <olcott@worldnet.att.net> said:
> ...
> All that Turing's proof showed was that you can not construct a halt
> analyzer that returns its result back to the program being analyzed.

Nonsense.  You don't understand Turing's proof, and you don't understand
the Halting Problem.

> This has been taken to mean (but does not mean) that
> 
> No program can ever be written to determine whether any arbitrary
> program will halt.
> 
> If the only possible way to construct a halt analyzer always required
> that the result must be returned to the program being analyzed, 

This is ill-defined rubbish.  Turing's proof has nothing to do with
results being returned to "the program being analyzed".  If you
understood the proof and the mathematics behind it, you'd see that this
is so.

> then Turing's proof would have been correct.  Since it is possible to
> create a halt analyzer that does not return its result back to the
> program being analyzed, then Turing proof is not correct. 

Then show the flaw in the proof.  A nice simple version of it has been
posted.  It would appear that you ignore it because you cannot deal with
the actual mathematics of the problem.

On Sat, 24 Jul 2004 03:49:30 GMT, Peter Olcott <olcott@worldnet.att.net> said:
>> OK. Let's assume that Halt's return value may not be tested. What does
>> that prove?
> 
> It proves that the following statement is not proven to be true:
> No program can ever be written to determine whether any
> arbitrary program will halt.

It obviously doesn't.  Turing proved that no such program can be
written.  So your claim must be false.  Unless, of course, you can find
a flaw in the proof.  A simple exposition of the Halting Problem has
been posted for you.  Find the flaw in the proof.  If there isn't one
(and there isn't), you are obviously wrong.

>> It only proves that the standard proof that the halting problem cannot
>> be solved cannot be used to attack your program. That does not mean that
>> there is no proof at all that can be used to attack your program; and it
>> most certainly does not mean that you have solved the halting problem
>> just because the standard proof doesn't work.
> 
> It means that I have correctly refuted the original proof that the problem
> can not possibly be solved.

Not unless you can find a flaw in the original proof.  You haven't.  So
what you say is obviously false.

>> You are essentially saying this: "If we disregard Turing's rules of how
>> Turing machines work,
> 
> Not at all. All that we have to do is to see that there is more than
> one possible way to construct a halt analyzer. It is not a logical
> necessity to return the result of the halt analyzer to its caller. 

Whatever this means, Turing showed that there is no Turing machine
(equivalently, no program -- no program of any sort) can solve the
Halting Problem.  So clearly, your result -- if you have a result -- has
nothing to do with Turing machines or Turing complete programming
languages.

> It only solves the problem in the sense that the original proof's
> statement that solving this problem is impossible, is incorrect.

What is impossible is a solution to the Halting Problem -- unless there
is a flaw in Turing's proof.  As you've never identified such a flaw --
and you won't, as the proof is as clear and straightforward as any in
mathematics -- you are clearly wrong.

-cm

Peter Olcott wrote:
> Since it is possible to create a halt analyzer that does not
> return its result back to the program being analyzed

It's not possible.  That's why your disproof is wrong.

, then
> Turing proof is not correct. It is as simple as that.
> 
> 
> 
> 

Peter Olcott wrote:
> "Gergo Barany" <gergo@tud.at> wrote in message news:slrncg1n3k.ppl.gergo@hold.otthon.at...
> 
>>Peter Olcott <olcott@worldnet.att.net> wrote:
>>
>>> No. I have defined the solution to the Halting Problem such that
>>> the programs that make a solution impossible aren't possible.
>>> This includes any program that tests the return value of Halt().
>>
>>OK. Let's assume that Halt's return value may not be tested. What does
>>that prove?
> 
> 
> It proves that the following statement is not proven to be true:
> No program can ever be written to determine whether any
> arbitrary program will halt

Only if a program can be written that solves halt without returning
its value.  It can't.

> 
> 
>>It only proves that the standard proof that the halting problem cannot
>>be solved cannot be used to attack your program. That does not mean that
>>there is no proof at all that can be used to attack your program; and it
>>most certainly does not mean that you have solved the halting problem
>>just because the standard proof doesn't work.
> 
> 
> It means that I have correctly refuted the original proof that the problem
> can not possibly be solved.

Only if a program can be written that solves halt without returning
its value.  It can't.

> 
> 
>>You are essentially saying this: "If we disregard Turing's rules of how
>>Turing machines work,
> 
> 
> Not at all. All that we have to do is to see that there is more than one
> possible way to construct a halt analyzer. It is not a logical necessity
> to return the result of the halt analyzer to its caller. If this is the only
> possible way to construct a halt analyzer, then Turing's proof would have
> been correct. Since this is not the only possible way to construct
> a halt analyzer, Turing's proof is incorrect.

True, it's not the only possible way to construct a halt analyzer.
False that you can construct a halt analyzer that doesn't return
its value.

> 
> 
>>his proof cannot be applied." Well, big deal. How
>>does that solve the halting problem?
> 
> 
> It only solves the problem in the sense that the original proof's
> statement that solving this problem is impossible, is incorrect.

Only if you can construct a halt analyzer that doesn't return
its value.  You can't.

> 
> 
>>BTW, ist first-order logic decidable in your universe?
>>
>>
>>Gergo (de-lurking)
>>-- 
>>Chicken Little was right.
> 
> 
> 

Peter Olcott wrote:
> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:GrjMc.173166$XM6.124562@attbi_s53...
> 
>>Peter Olcott wrote:
>>
>>>My idea works for the universal set of all possible programs.
>>>This is a true fact. There is no loophole around it.
>>
>>Except that we've proven your program doesn't exist and you've
>>never refuted that.
>>
> 
> 
> All that I have conclusively proven is that the original proof that:
> 
> No program can ever be written to determine whether any
> arbitrary program will halt
> 
> is incorrect.

Only if you can write a program that determines whether
any arbitrary program will halt.  You can't.

> 
> 

Peter Olcott wrote:
> "Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2mcfuaFkaq8kU1@uni-berlin.de...
> 
>>Peter Olcott wrote:
>>
>>>"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2m9cgjFkj9b4U1@uni-berlin.de...
>>>
>>>>>Peter Olcott wrote:
>>>>
>>>>>All that I need to do is to make the original counter-example
>>>>>impossible to create in at least one instance, then I have provided
>>>>>the counter-counter-example.
>>>>
>>>>That doesn't sound like good logic. Just fixing one
>>>>counterexample does not necessarily preclude other
>>>>counterexamples from existing.
>>>
>>>This is not required.
> 
> 
> 
> It is not my goal to prove this statement true:
> A program can definitely be  written to determine whether any arbitrary
> program will halt
> 
> My only goal is to show that the proof of this statement:
> No program can ever be written to determine whether any arbitrary
> program will halt
> 
> is incorrect.

Only if its possible to write a program to determine whether
any arbitrary program will halt.  It can't.

> 
> 
> 
> 
>>Er... yes it is. To prove: not forall x P(x), one can prove
>>exists x not P(x). for the latter one may produce the thing
>>c, called a counterexample, such that not P(c). Suppose one
>>finds a flaw in the justification that not P(c) is true. I
>>think you are claiming to have done this. But your claim
>>(true or not) does not (necessarily!) prevent another
>>element d from existing such that not P(d).
>>
>>I'm not sure either of us is saying relevant things at this
>>point though.
>>
>>
>>>My goal is to merely correctly refute the original proof.
>>
>>OK.
>>
>> > I did that.
>>
>>I disagree.
>>
>>-- 
>>Mitch Harris
>>(remove q to reply)
>>
> 
> 
> 

Peter Olcott wrote:
>>- what I consider to be the original counter-example program
>>already doesn't exist. I think the name we've given it here
>>is not appropriate. Turing constructed a TM, using a TM that
>>hypothetically already solves the Halting problem. This
>>construction (what I think we are calling "the counter
>>example") is contradictory and so at least one of the
>>hypotheses is wrong, and we choose the existence of a TM for
>>the Halting Problem to be the wrong one.
> 
> 
> Yes, at least one of the assumptions is wrong. What about the
> assumption that you must return that result of the halt analysis
> back to the program being analyzed?

That's not an assumption because you can construct a program
that does return its value from one that doesn't return its
value trivially.  Therefore a program that analyzes halt but
does not return its value cannot exist.

> 
> http://home.att.net/~olcott/halting/example.html
> Let's use the terminology of this link for our basis.
> All of these programs can exist.

No, they can't and saying they can doesn't make it so.

> 
> 
>>>It can still exist.
>>
>>You confuse me terribly. You just said make it impossible to
>>exist (even though it already doesn't exist), and now you
>>say it exists. Are you changing "it"'s?
>>
>>
>>>It can still have access to the return results
>>>of another corrupted version of WillHalt(). My uncorrupted
>>>version will correctly determine halting in all cases.
>>
>>As many people have already told you (and each of those many
>>people have often told you), this is just a different
>>construction, it doesn't invalidate Turing's construction.
>>
>>-- 
>>Mitch Harris
>>(remove q to reply)
>>
> 
> 
> 

Peter Olcott wrote:
>>Let me state, in yet another different way, why your "void
>>WillHalt(P,q)" function cannot exist. I will number the
>>sentences, so that you can easily specify which statement you
>>don't agree with.
>>
>>[1] In order to create "void WillHalt" you need code to decide
>>the halting problem.
>>
>>[2] Turing proved that this code cannot exist.
> 
> 
> Turing only proved that bool WillHalt() can not exist. He proved nothing
> at all about void WillHalt(). 

But we can construct bool WillHalt() trivially from void WillHalt()
so void WillHalt() cannot exist.

It is possible to construct a halt analyzer that
> does not return its result back to the program being analyzed.

No, it isn't.

  When this
> result is returned back to the program being analyzed, this result changes
> the behavior of the program being analyzed, and thus the resulting halt
> analysis varies depending upon whether the result is returned back to the
> program being analyzed or not.

No, because void WillHalt() does not exist, so it can't be change
behavior and it can't be modified.  It doesn't exist.

> 
> 
>>[3] Since your function depends on this code, it cannot exist.
>>
>>Which sentence do you not agree with?
>>
>>This is what you do: you take code, which provably does not
>>exist, add a security mechanism, and claim that suddenly the
>>code does exist.
>>
>>It's analagous to the following argument: "It is not true
>>that square circles don't exist, because we can put one in a
>>safe so that nobody can see it anymore."
>>
>>groente
>>-- Sander
>>
> 
> 
> 

Peter Olcott wrote:
>>>But, I have already solved this problem. If the analyzer is changed so
>>>that it does not return its result back to its caller, then what was
>>>called the "Halting Problem" can not occur.  (Show me how it can occur
>>>if you disagree).

You cannot construct the analyzer regardless of whether it returns
its result or not.  That's what you keep missing.

>>
>>The problem with this concept is that the analyzer you're modifying so it
>>doesn't return it's result doesn't happen to exist.  You've started from a
> 
> 
> I asked you to show me how it can occur if your disagree. You are not
> showing me how it can occur. You are merely claiming without supporting
> the claim. You are beginning with one assumption, and deriving another
> assumption from it.

If void WillHalt() existed, then bool WillHalt() could be
trivially constructed from void WillHalt(). bool WillHalt()
cannot exist so void WillHalt() cannot exist.

> Show me via a detailed execution trace of exactly why my reasoning is
> incorrect. Point me to the exect line number where my reasoning fails.

You can't show an execution trace for a program that cannot exist.
The exact point where your reasoning fails is when you assume
that void WillHalt() can exist.  It can't.

> 
> 
>>false premise.  Starting from a false premise is fine if what you're
>>trying to prove is the falseness of the premise - that's proof by
>>contradiction.  It doesn't work if you're trying to prove something
>>dependent on the truth of the premise.
>>
>>The analyzer you're claiming to modify to debunk the proof was proven not
>>to exist by the proof you're trying to debunk.
>>
>>
>>
> 
> 
> 

On Sat, 24 Jul 2004 04:18:47 +0000, Peter Olcott wrote:

>> > But, I have already solved this problem. If the analyzer is changed
>> > so that it does not return its result back to its caller, then what
>> > was called the "Halting Problem" can not occur.  (Show me how it can
>> > occur if you disagree).
>>
>> The problem with this concept is that the analyzer you're modifying so
>> it doesn't return it's result doesn't happen to exist.  You've started
>> from a
> 
> I asked you to show me how it can occur if your disagree. You are not
> showing me how it can occur. You are merely claiming without supporting
> the claim. You are beginning with one assumption, and deriving another
> assumption from it.
> 
I'm beginning with something that's been been proven.  You are in fact
assuming that you have an analyzer that you can change so it doesn't
return its value.  This assumption has been proved false.

> Show me via a detailed execution trace of exactly why my reasoning is
> incorrect. Point me to the exect line number where my reasoning fails.
> 
> 
Execution traces of nonexistent programs are not possible.

Your (partial) source code for void WillHalt:

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  // This code never gets executed if the solution is properly implemented 
10     SecureOutput("Security Has Been Breached, Take Corrective Action"); 
11  }


Your reasoning fails at line #3.  It assumes the existence of

	 bool TheProgramWillHalt(string SourceCode, string InputData)

and this function was proven not to exist by Turing.

Marc Goodman <marc.goodman@comcast.net> writes:

> Peter Olcott wrote:
> [...]
> > All that I have conclusively proven is that the original proof that:
> > No program can ever be written to determine whether any
> > arbitrary program will halt
> > is incorrect.
> 
> Only if you can write a program that determines whether
> any arbitrary program will halt.  You can't.

Maybe people can't identify Peter Olcott's spark of "genius".
His is an circular argument, and goes something like this:

- if "WillHalt" of some description existed
- then the standard Halting Problem proof might be gotten around somehow
- and therefore "WillHalt" might exist


- FChE

> I'm beginning with something that's been been proven.  You are in fact
> assuming that you have an analyzer that you can change so it doesn't
> return its value.  This assumption has been proved false.
>
> > Show me via a detailed execution trace of exactly why my reasoning is
> > incorrect. Point me to the exect line number where my reasoning fails.
> >
> >
> Execution traces of nonexistent programs are not possible.
>
> Your (partial) source code for void WillHalt:
>
> 1  void WillHalt(string SourceCode, string InputData)
> 2  {
> 3    if (TheProgramWillHalt(SourceCode, InputData))
> 4     SecureOutput("The Program Will Halt");
> 6    else if (TheProgramWillNotHalt(SourceCode, InputData))
> 7     SecureOutput("The Program Will Not Halt");
> 9    else  // This code never gets executed if the solution is properly implemented
> 10     SecureOutput("Security Has Been Breached, Take Corrective Action");
> 11  }
>
>
> Your reasoning fails at line #3.  It assumes the existence of
>
> bool TheProgramWillHalt(string SourceCode, string InputData)
>
> and this function was proven not to exist by Turing.
>
Close but no cigar. This function was proven to not exist by Turing
iff it returned its result to all callers. Since this function does not
return its result to all callers (it is an internal function to void WillHalt()
and inaccessible to all others) Turing's proof does not apply.

> If void WillHalt() existed, then bool WillHalt() could be
> trivially constructed from void WillHalt(). bool WillHalt()
> cannot exist so void WillHalt() cannot exist.
>
> > Show me via a detailed execution trace of exactly why my reasoning is
> > incorrect. Point me to the exect line number where my reasoning fails.
>
> You can't show an execution trace for a program that cannot exist.
> The exact point where your reasoning fails is when you assume
> that void WillHalt() can exist.  It can't.

That's merely an empty unsupported claim, can't you do better than that?

> No, because void WillHalt() does not exist, so it can't be change
> behavior and it can't be modified.  It doesn't exist.
>
> >>groente
> >>-- Sander

Yet another empty unsupported claim, can't you do better than that?

"Peter Olcott" <olcott@att.net> wrote in message news:<Oh_Ic.91468$OB3.15698@bgtnsc05-news.ops.worldnet.att.net>...
> 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.
> 
[snip]


Could you construct a Turing machine that can determine if every
Turing machine halts?


Alex Vinokur
     http://mathforum.org/library/view/10978.html
     http://sourceforge.net/users/alexvn

> > Yes, at least one of the assumptions is wrong. What about the
> > assumption that you must return that result of the halt analysis
> > back to the program being analyzed?
>
> That's not an assumption because you can construct a program
> that does return its value from one that doesn't return its
> value trivially.  Therefore a program that analyzes halt but
> does not return its value cannot exist.

Let's make a little analogy here. You can't ever make a program
that runs correctly because it is trivial to smash the computer
making the program not run correctly.

Exactly how does the fact that you can corrupt one program in any
way effect the capability of the original uncorrupted program?

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:_DqMc.175998$XM6.111524@attbi_s53...
> > It is not my goal to prove this statement true:
> > A program can definitely be  written to determine whether any arbitrary
> > program will halt
> >
> > My only goal is to show that the proof of this statement:
> > No program can ever be written to determine whether any arbitrary
> > program will halt
> >
> > is incorrect.
>
> Only if its possible to write a program to determine whether
> any arbitrary program will halt.  It can't.

Yet another empty unsupported claim, can't you do better than that?

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:ZCqMc.175991$XM6.19332@attbi_s53...
> Peter Olcott wrote:
> > "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:GrjMc.173166$XM6.124562@attbi_s53...
> >
> >>Peter Olcott wrote:
> >>
> >>>My idea works for the universal set of all possible programs.
> >>>This is a true fact. There is no loophole around it.
> >>
> >>Except that we've proven your program doesn't exist and you've
> >>never refuted that.
> >>
> >
> >
> > All that I have conclusively proven is that the original proof that:
> >
> > No program can ever be written to determine whether any
> > arbitrary program will halt
> >
> > is incorrect.
>
> Only if you can write a program that determines whether
> any arbitrary program will halt.  You can't.

Yet another empty unsupported claim, can't you do better than that?

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:mCqMc.175385$Oq2.78595@attbi_s52...
> > It proves that the following statement is not proven to be true:
> > No program can ever be written to determine whether any
> > arbitrary program will halt
>
> Only if a program can be written that solves halt without returning
> its value.  It can't.

Yet another empty unsupported claim, can't you do better than


> > Not at all. All that we have to do is to see that there is more than one
> > possible way to construct a halt analyzer. It is not a logical necessity
> > to return the result of the halt analyzer to its caller. If this is the only
> > possible way to construct a halt analyzer, then Turing's proof would have
> > been correct. Since this is not the only possible way to construct
> > a halt analyzer, Turing's proof is incorrect.
>
> True, it's not the only possible way to construct a halt analyzer.
> False that you can construct a halt analyzer that doesn't return
> its value.

Why the hell not? It is by no means at all impossible to
write a function that does not return a value to its caller.
This is a standard feature of many programming languages.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message
news:2m6ng9Fjjno7U1@uni-berlin.de...
| Peter Olcott wrote:
| > I am not nearly as
| > good with words as I am with logic, that (and/or Groupthink)
| > is why most people have not yet fully understood what I
| > am saying.
|
| appeal to authority and its varieties is a fallacy that
| every science is susceptible to. Of all the sciences,
| mathematics is the least susceptible because everybody has
| access to the same data, and can do the same experiments to
| corroborate or falsify. If you want to convince people,
| citing Groupthink as a parry is not likely to be a succesful
| strategy.

Peversely, Peter has appealed to authority by citing the 'groupthink'
concept.  Ironic, eh?

I did a litle survey of some contributors to this debate.  The
groupthink mentality came up with the following conclusion about
Peter:

troll: 33%
idiot: 33%
kook:  33%

The figures used in this survey have been rounded in order to protect
the identities of the participants.
--
<�)&&PARR##sss==<(

"Will Twentyman" <wtwentyman@read.my.sig> wrote in message
news:40fe9402_2@newsfeed.slurp.net...
| Peter Olcott wrote:
| > "Kenneth Doyle" <nobody@notmail.com> wrote in message
news:Xns952D9CBB490B0nobodynotmailcom@61.9.191.5...
| >>"Peter Olcott" <olcott@worldnet.att.net> wrote in
| >>news:EiiLc.292221$Gx4.63033@bgtnsc04-news.ops.worldnet.att.net:

| >>>I am not the best writer, and that is part of the problem.

| >>But Peter, you are a expert in semantics; remember?  <...>
| >
| > It a well known fact that those that are good at logic/math
| > are not good a writing. It has to do with the size of the Corpus
| > Callosum.
|
| I'll have to go tell my wife to stop being good at one of them.  I
| wonder which one she'll pick.

This little corner of the thread is becoming redolent with innuendo.

I suppose the spam merchants will be assailing us with 'Ashamed of
the size of your leetle corpus callosum?' next.

But seriously.  Peter now asserts 'poor at writing' implies 'good at
logic'.  And of course, that inevitbabbly leads to 'poor at logic'
implies 'good at writing'.  I had the luck to be born good at logic.
When I was a child, I was not too good at writing.  I had to work at
that skill.  I suppose I was too stupid to measure the size of my
corpus callosum and realise that there's no way I could write well
and with clarity.

Sorry, Peter, I have just dashed your CC theory to scintillating
smithereens.  I am both illogical and a poor writer.
--
<�)&&PARR##sss==<(   Parr

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:um0Mc.165613$XM6.126175@attbi_s53...
> Peter Olcott wrote:
> >>This in no way answers the above question.  Here it is stated
> >>more simply: Were you wrong that your program was not limited
> >>to Turing machines,

The answer depends upon exactly how far that the definition of a
Turing Machine is extended. If the definition of a Turing Machine
extends to whatever extent is required to make the Church-Turing
thesis true, then my machine with protected memory, ROM memory,
and write only (screen) memory is a Turing Machine.

In fact this would form a very good improvement to my website.
The answer to my first objection can be greatly simplified.

> or were you wrong that any computation
> >>that can be carried out by mechanical means can be performed
> >>by some Turing machine,
> or were you wrong that your program
> >>works.  It has to be one or the other.  Lucky you, you get
> >>to pick exactly which mistake you made, and we'll proceed from
> >>there.
>
> Since you've chosen to ignore the question once again,
> here it is repeated in all its glory.  I eagerly
> await a response the third time around.
>

"Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns952F61553C2C2nobodynotmailcom@61.9.191.5...
> "Peter Olcott" <olcott@worldnet.att.net> wrote in
> news:IZXLc.305676$Gx4.108138@bgtnsc04-news.ops.worldnet.att.net:
>
> > I merely redefined the halt analyzer such that the means to
> > prove that a solution to the Halting Problem can not exist,
> > can not exist.
> >
>
> But the means by which a solution to halting problem has been proved not to
> exist is logical argument.  Do you really wish to imply that your argument
> makes logic impossible?

The original argument relied upon the assumption that the only
possible way to construct a halt analyzer was to always return
its result to every possible caller. If this assumption was true
then the original proof would be correct.

Since this assumption is not true, therefore the proof is incorrect.

> > I don't see why everyone here is not getting this:
> > Producing a version of WillHalt that does not work
> > in no way refutes another version that does work.
> >
> > (a) void WillHalt() always works
> > (b) bool WillHalt() does not work on some inputs
> >
> > From (b) you can conclude nothing at all about (a).
>
> a -> not(b)
> b -> not(a)
>
> Regardless of the method of output, it either does or does not work.
> You are focused on output instead of code.

The method of output does indeed make all the difference
and here is why:
http://home.att.net/~olcott/halting/index.html#objection03

> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>

> Could you construct a Turing machine that can determine if every
> Turing machine halts?

No, the most that I can do is show that the original proof that this is
impossible, is incorrect.

>
> Alex Vinokur
>      http://mathforum.org/library/view/10978.html
>      http://sourceforge.net/users/alexvn

"Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns9530930741A2Dnobodynotmailcom@61.9.191.5...
> "Peter Olcott" <olcott@worldnet.att.net> wrote in
> news:YflMc.129177$OB3.119435@bgtnsc05-news.ops.worldnet.att.net:
>
> > Yes, at least one of the assumptions is wrong. What about the
> > assumption that you must return that result of the halt analysis
> > back to the program being analyzed?
> >
>
> Yes, that's a terrible assumption to make about a function that is defined
> to return the result of the halt analysis back to the function that called
> for the result.

And it proves that no other form of halt analyzer can possibly exist?

Peter Olcott says...

>Exactly how does the fact that you can corrupt one program in any
>way effect the capability of the original uncorrupted program?

Why in the world do you think that it is *corrupting* a program
to put in a return value?

The assumption that everyone but you is making is this:

  For any program

     void H1(String x) 

  that computes a boolean value and writes that value to the computer
  screen, there is another program

     boolean H2(String x)

  with the property that for all possible inputs x,

     If H1(x) writes "true" to the screen, then
         H2(x) returns true.
     If H1(x) writes "false" to the screen, then
         H2(x) returns false.

Program H2 is *not* broken or corrupted, it simply
uses a different channel for returning its output.

Do you think this assumption is false? If so, *why*?
What's a concrete example of a program that writes to
the screen such that the output cannot be converted into
a return value?

What it seems to me that you are saying is that you
can construct a version of WillHalt that is *useless*
as a computer algorithm. Algorithms are useful because
they can be used *inside* other programs. Your version
of WillHalt is useless as an algorithm.

Turing's original proof was about programs that can
be used inside other programs. In other words, his
proof was about *useful* programs. You haven't shown
his proof to be incorrect---instead, you have shown
that his proof fails for a larger class of programs
that includes useless programs.

--
Daryl McCullough
Ithaca, NY

Peter Olcott says...

>> Regardless of the method of output, it either does or does not work.
>> You are focused on output instead of code.
>
>The method of output does indeed make all the difference
>and here is why:
>http://home.att.net/~olcott/halting/index.html#objection03

Here's what you say:

"The thing to remember here is that the calling program and the program being
analyzed are the same program. If returning a value to the calling program
changes its behavior, then it also changes the behavior of the program being
analyzed, because they are the same program."

Let's go through the logic of this one more time:

Let WillHaltPO(x,y) be a program that takes an arbitrary string x
and string y, and prints "true" to the computer screen if x is a
code for a program that halts on input y, and prints "false" to the
screen otherwise. WillHaltPO(x,y) has no return value.

Let WillHaltMod(x,y) be a program with the following behavior:

     For any inputs x and y:
     If WillHaltPO(x,y) prints "true" to the screen, then
     WillHaltMod(x,y) returns true.
     If WillHaltPO(x,y) prints "false" to the screen, then
     WillHaltMod(x,y) returns false.

Are you saying that it is *impossible* to construct the program
WillHaltMod? Why doesn't the following procedure work:

      1. Copy the source code for WillHaltPO.
      2. Change the return type to boolean.
      3. Search for statements of the form
             outputToScreen(x)
         (or whatever the syntax is)
      4. Replace each one by "return x;"

--
Daryl McCullough
Ithaca, NY

>>>>> "Peter" == Peter Olcott <olcott@worldnet.att.net> writes:

    Peter> Let's make a little analogy here. You can't ever make a
    Peter> program that runs correctly because it is trivial to smash
    Peter> the computer making the program not run correctly.

Smashing into a computer change the interpretation of the answers of
the computer.  The modifications we talked about doesn't.

    Peter> Exactly how does the fact that you can corrupt one program
    Peter> in any way effect the capability of the original
    Peter> uncorrupted program?

Your whole point is that "if you modify my halting solver to return a
boolean value, then your result about my halting solver can't exists
does not carry to my program, because it's a different program."  This
would be correct if my modification make the programs answer
differently---i.e., some input that the original program would answer
"yes", say on the screen, would cause the modified program to return
"no"; or vice-versa.

But as long as you modify your program correctly, this is not the
case.  That is, if your program has a reasonable notion of "printing
to the screen and terminate" to answer whether the input is a halting
instance.  You simply modify any location of your program that prints
to screen to check what you are printing, and if it is "yes" then you
instead cause the WillHalt function return 1 using whatever mechanism
available, and if it is "no" then you makes it return 0.  Then the
modified program can be proved to have equivalent behaviour to yours,
except that while your program would output to screen, the modified
program return boolean.

Then your whole argument breaks down.  I don't have to attack your
program directly, but instead attack the modified version of your
program.  Assume your program really exists, then the modified version
must also exist, and the modified program is proved to behave exactly
the same as your program apart from the way it outputs.  Since I can
show you that the no program would exhibit that behaviour, this leads
to a contradiction.  So your program cannot exist either.

This is the whole strategy of the proof of the impossibility of
Halting problem: once you know that the halting problem of Turing
machines cannot be solved in Turing machines itself, you also know
that the halting problem for any Turing equivalent machine (or
"Turing-capable" machine, i.e., able to express the computation of a
Turing machine) cannot be solved using anything with no stronger power
than a Turing machine.

Regards,
Isaac.

"Peter Olcott" <olcott@worldnet.att.net> wrote in message news:ZBuMc.316229$Gx4.310588@bgtnsc04-news.ops.worldnet.att.net...
> > Could you construct a Turing machine that can determine if every
> > Turing machine halts?
>
> No, the most that I can do is show that the original proof that this is
> impossible, is incorrect.
>
[snip]

Do you plan to build such a Turing machine in the future?
That might help to test your disproof.


-- 
   Alex Vinokur
     http://mathforum.org/library/view/10978.html
     http://sourceforge.net/users/alexvn

Peter Olcott <olcott@worldnet.att.net> wrote:
>"Marc Goodman" <marc.goodman@comcast.net> wrote in message
>> > It proves that the following statement is not proven to be true:
>> > No program can ever be written to determine whether any
>> > arbitrary program will halt
>>
>> Only if a program can be written that solves halt without returning
>> its value.  It can't.
>
>Yet another empty unsupported claim

He did not utter a support for that claim because 
- it has been well supported elsewhere in this thread, many times
- it has been well supported many many more times elsewhere by many 
different trustworthy people.

Your claims have been supported only by you.

Appeal to numbers and authority vs appeal to rugged individualism?

At this point we're not really talking about any substance at all 
anyway. 

>> > Not at all. All that we have to do is to see that there is more than one
>> > possible way to construct a halt analyzer. It is not a logical necessity
>> > to return the result of the halt analyzer to its caller. If this
>is the only
>> > possible way to construct a halt analyzer, then Turing's proof
>would have
>> > been correct. Since this is not the only possible way to construct
>> > a halt analyzer, Turing's proof is incorrect.
>>
>> True, it's not the only possible way to construct a halt analyzer.
>> False that you can construct a halt analyzer that doesn't return
>> its value.
>
>Why the hell not? It is by no means at all impossible to
>write a function that does not return a value to its caller.
>This is a standard feature of many programming languages.

Sure. But then it is not a function!

Mitch

> | > What you really mean is that you do not understand that which you
> | > quoted.
> | Not at all. What I am saying from a professional programmer
> | perspective is that single letter names are bad programming.
> | They are not self-documenting.
>
> A professional programmer.
>
>
> OK
>
> It pleases me to know you realise how important it is to
> make things understandable.
>
> But nevertheless, do you understand the content of:
> http://www.netaxs.com/people/nerp/automata/halting2.html

yep.

> >>No, but it has to be something equivalent to a Turing Machine to count.
> >>  For your screen idea to work, it must necessarily not be equivalent to
> >>a Turing Machine.
> >>
> >
> > Another respondent suggested write only memory is the same
> > as a screen.
>
> How does that affect my statement?
>

I have re-written this to make it more clear.
http://home.att.net/~olcott/halting/index.html#objection01

> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>

> This is theory.  Lots of things can exist in theory, yet not in reality.
>   Then again, there are now devices that are designed to be true random
> number generators, not pseudo-random number generators.  A random number
> generator that is truly random is one type of oracle.
>
> In reality, I think what you may be attempting to do is create an oracle
> WillHalt() and claim that it is actually a TM WillHalt() without
> realizing it.
>
> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>
No its nothing at all like that.
I merely do not return the result of the Halt analysis
to the program being analyzed

Peter Olcott <olcott@worldnet.att.net> wrote:
>> - what I consider to be the original counter-example program
>> already doesn't exist. I think the name we've given it here
>> is not appropriate. Turing constructed a TM, using a TM that
>> hypothetically already solves the Halting problem. This
>> construction (what I think we are calling "the counter
>> example") is contradictory and so at least one of the
>> hypotheses is wrong, and we choose the existence of a TM for
>> the Halting Problem to be the wrong one.
>
>Yes, at least one of the assumptions is wrong. What about the
>assumption that you must return that result of the halt analysis
>back to the program being analyzed?

That is an assumption about how TMs are defined. So if a TM is 
defined differently, then maybe you can get a solvable halting problem 
for that -new- kind of machine. But that doesn't change the fact that 
it works for the good ol' fashioned TM.

Mitch

Peter Olcott <olcott@worldnet.att.net> wrote:
>> >>An appeal to authority is very relevant when the authority
>> >>is an expert in the field in question. In such a case, the
>> >>appeal is not a fallacy.
>> >
>> > In deductive logic, it is always an error.
>> > It becomes valid in inductive logic.
>>
>> OK. I'll accept that. That's a very reasonable distinction.
>>
>It's just the facts.

If by "fact" you mean social convention. :)

Mitch

>>>>> "Peter" == Peter Olcott <olcott@worldnet.att.net> writes:

    Peter> All that Turing's proof showed was that you can not
    Peter> construct a halt analyzer that returns its result back to
    Peter> the program being analyzed.  This has been taken to mean
    Peter> (but does not mean) that

    Peter> No program can ever be written to determine whether any
    Peter> arbitrary program will halt.

There are two "program"s in your sentences above, and I assume that
you mean that the first "program" is not more powerful than Turing
machines; and the second "program" is not weaker (e.g., you do not
mean that "No program can ever be written to determine whether any
finite automata will halt").

Your description suggests that the proof that "halting problem for
Turing machines is unsolvable using Turing machines" is "interpreted"
further without much thoughts.  This is not the truth.

What theoreticians "interpret" is instead that

  The halting problem for any type of machine capable of expressing
  the Turing machine computations cannot be solved using any type of
  machine that the Turing machine is capable of expressing.

Here "a machine of type A capable to express a machine of type B"
means we can, using a Turing machine, mechanically convert a machine
of type A to a machine of type B.

E.g., in order to prove that the halting problem is unsolvable in the
context of "Random Access Machine" (RAM), i.e., a machine similar to a
Turing machine but with the addition of Random access memory, then one
would have to prove that (1) there is a Turing machine which converts
every Turing Machine to an equivalent RAM; and then (2) there is a
Turing machine which converts every RAM to an equivalent Turing
Machine.  Both of these can be done, so the above "interpretation"
works to show that the halting problem is unsolvable in RAM.  Note
that theoreticians *don't* "rerun" the arguments of the halting
problem unsolvability proof of the Turing machine in the context of
RAM.  It is unnecessary, and it is not guaranteed to be possible.

Why the above "interpretation" is correct?  It is simple logic: if
such a machine exists, then we would have a Turing machine that solve
the halting problem for the Turing machines.  The machine would
consists of a stage to convert the input Turing machines into the
equivalent machine of the "stronger" type.  Then, after the input is
"assimilated", a Turing machine (simulator of the halting solver in
another context) is used to run on that modified input.  But we
already know that such Turing machines cannot exist, so we have a
contradiction.  (Technically, there doesn't need to be a Turing
machine to create the simulator, the mere existance of the simulator
is sufficient for the impossibility of halting solver to carry over.)

I leave it to you as an exercise to check that your machines indeed
can be simulated using a Turing machine, and thus have no power to
solve the halting problem for any Turing-equivalent machines
(including regular programs if we assume infinite memory).

Regards,
Isaac.

Peter Olcott <olcott@worldnet.att.net> wrote:
>
>Since it is possible to create a halt analyzer that does not
>return its result back to the program being analyzed, then
>Turing proof is not correct. 

How can that possibly follow? How does the existence of an object with 
one property deny the existence of another object with the opposite 
property?

Mitch

Peter Olcott says...

>The original argument relied upon the assumption that the only
>possible way to construct a halt analyzer was to always return
>its result to every possible caller. If this assumption was true
>then the original proof would be correct.

It didn't *assume* that that was the only way to return a value.
That's the *definition* of what it means to "solve the halting
problem". If you want to have a broader definition, fine---that
doesn't invalidate Turing's proof.

--
Daryl McCullough
Ithaca, NY

> > It is not merely that I have not accepted a proof that everyone
> > else accepts. It is that my disprove of this proof has not yet
> > been found in error. If you think that any of the refutations of
> > my refutation were valid, then state which one(s).  I have
> > found serious flaws in everyone of them.
>
> The problem is that your construction is not a disproof, but is
> tangential to the proof you object to.  Your argument simply has no
> impact on the proof.  You have yet to prove that your version of
> WillHalt() exists, only that it is not amenable to the standard
> contradiction if it does exist.

In other words my version of void WillHalt() can not be proven
to not possibly exist using the original reasoning?

> -- 
> Will Twentyman
> email: wtwentyman at copper dot net
>

On Sat, 24 Jul 2004 13:27:25 +0000, Peter Olcott wrote:

>> I'm beginning with something that's been been proven.  You are in fact
>> assuming that you have an analyzer that you can change so it doesn't
>> return its value.  This assumption has been proved false.
>>
>> > Show me via a detailed execution trace of exactly why my reasoning is
>> > incorrect. Point me to the exect line number where my reasoning fails.
>> >
>> >
>> Execution traces of nonexistent programs are not possible.
>>
>> Your (partial) source code for void WillHalt:
>>
>> 1  void WillHalt(string SourceCode, string InputData)
>> 2  {
>> 3    if (TheProgramWillHalt(SourceCode, InputData))
>> 4     SecureOutput("The Program Will Halt");
>> 6    else if (TheProgramWillNotHalt(SourceCode, InputData))
>> 7     SecureOutput("The Program Will Not Halt");
>> 9    else  // This code never gets executed if the solution is properly implemented
>> 10     SecureOutput("Security Has Been Breached, Take Corrective Action");
>> 11  }
>>
>>
>> Your reasoning fails at line #3.  It assumes the existence of
>>
>> bool TheProgramWillHalt(string SourceCode, string InputData)
>>
>> and this function was proven not to exist by Turing.
>>
> Close but no cigar. This function was proven to not exist by Turing
> iff it returned its result to all callers. Since this function does not
> return its result to all callers (it is an internal function to void WillHalt()
> and inaccessible to all others) Turing's proof does not apply.

A function returns its result to its caller.  This is the definition of a
function.  This function was proven not to exist.

If it exists as an internal function to a program, then *IT EXISTS*.  The
very existence of such a function is precisely what Turing disproved. 
Containment inside the context of another program is irrelevant.  If it
exists, it can be removed from that context and stand on its own returning
its value to whatever calls it.

You need to go study logic.  Your confusion is entirely in the logic of
existence, universality and implication.  It has nothing to do with
programming.

>    If there is a program P1 that sends its outputs to the screen,
>    then there is a modified program P2 that returns its outputs
>    as a return value.
>
> Exactly *how* you make your outputs is irrelevant.

No it is not, and the following link explains exactly why.
http://home.att.net/~olcott/halting/index.html#objection03
If you form your refutation without first reading this, I will
not respond to it.

> --
> Daryl McCullough
> Ithaca, NY
>

Peter Olcott wrote:
>>If void WillHalt() existed, then bool WillHalt() could be
>>trivially constructed from void WillHalt(). bool WillHalt()
>>cannot exist so void WillHalt() cannot exist.
>>
>>
>>>Show me via a detailed execution trace of exactly why my reasoning is
>>>incorrect. Point me to the exect line number where my reasoning fails.
>>
>>You can't show an execution trace for a program that cannot exist.
>>The exact point where your reasoning fails is when you assume
>>that void WillHalt() can exist.  It can't.
> 
> 
> That's merely an empty unsupported claim, can't you do better than that?
> 
> 

If void WillHalt() existed, bool WillHalt() could be constructed
from it trivially.  bool WillHalt() cannot exist, therefore void
WillHalt() cannot exist.

Peter Olcott wrote:
>>No, because void WillHalt() does not exist, so it can't be change
>>behavior and it can't be modified.  It doesn't exist.
>>
>>
>>>>groente
>>>>-- Sander
> 
> 
> Yet another empty unsupported claim, can't you do better than that?
> 
> 

If void WillHalt() existed, bool WillHalt() could be constructed
from it trivially.  bool WillHalt() cannot exist, therefore void
WillHalt() cannot exist.

Peter Olcott wrote:
>>>Yes, at least one of the assumptions is wrong. What about the
>>>assumption that you must return that result of the halt analysis
>>>back to the program being analyzed?
>>
>>That's not an assumption because you can construct a program
>>that does return its value from one that doesn't return its
>>value trivially.  Therefore a program that analyzes halt but
>>does not return its value cannot exist.
> 
> 
> Let's make a little analogy here. You can't ever make a program
> that runs correctly because it is trivial to smash the computer
> making the program not run correctly.
> 
> Exactly how does the fact that you can corrupt one program in any
> way effect the capability of the original uncorrupted program?
> 
> 

You can't corrupt the program because the program cannot
exist in the first place.  You say you have a square
circle.  You say that it might be possible to knock the
corners off and get a round circle, but that doesn't mean
you don't have a square circle.

Truth is, you CAN'T have a square circle, because it's
in the nature of circles to be round.

Your program cannot exist.  Therefore your proof is invalid.

Peter Olcott wrote:
> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:_DqMc.175998$XM6.111524@attbi_s53...
> 
>>>It is not my goal to prove this statement true:
>>>A program can definitely be  written to determine whether any arbitrary
>>>program will halt
>>>
>>>My only goal is to show that the proof of this statement:
>>>No program can ever be written to determine whether any arbitrary
>>>program will halt
>>>
>>>is incorrect.
>>
>>Only if its possible to write a program to determine whether
>>any arbitrary program will halt.  It can't.
> 
> 
> Yet another empty unsupported claim, can't you do better than that?
> 
> 
If void WillHalt() existed, bool WillHalt() could be constructed
from it trivially.  bool WillHalt() cannot exist, therefore void
WillHalt() cannot exist.

Peter Olcott wrote:
> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:ZCqMc.175991$XM6.19332@attbi_s53...
> 
>>Peter Olcott wrote:
>>
>>>"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:GrjMc.173166$XM6.124562@attbi_s53...
>>>
>>>
>>>>Peter Olcott wrote:
>>>>
>>>>
>>>>>My idea works for the universal set of all possible programs.
>>>>>This is a true fact. There is no loophole around it.
>>>>
>>>>Except that we've proven your program doesn't exist and you've
>>>>never refuted that.
>>>>
>>>
>>>
>>>All that I have conclusively proven is that the original proof that:
>>>
>>>No program can ever be written to determine whether any
>>>arbitrary program will halt
>>>
>>>is incorrect.
>>
>>Only if you can write a program that determines whether
>>any arbitrary program will halt.  You can't.
> 
> 
> Yet another empty unsupported claim, can't you do better than that?
> 
> 
If void WillHalt() existed, bool WillHalt() could be constructed
from it trivially.  bool WillHalt() cannot exist, therefore void
WillHalt() cannot exist.

Peter Olcott wrote:
> "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:mCqMc.175385$Oq2.78595@attbi_s52...
> 
>>>It proves that the following statement is not proven to be true:
>>>No program can ever be written to determine whether any
>>>arbitrary program will halt
>>
>>Only if a program can be written that solves halt without returning
>>its value.  It can't.
> 
> 
> Yet another empty unsupported claim, can't you do better than
> 

If void WillHalt() existed, bool WillHalt() could be constructed
from it trivially.  bool WillHalt() cannot exist, therefore void
WillHalt() cannot exist.

> 
> 
>>>Not at all. All that we have to do is to see that there is more than one
>>>possible way to construct a halt analyzer. It is not a logical necessity
>>>to return the result of the halt analyzer to its caller. If this is the only
>>>possible way to construct a halt analyzer, then Turing's proof would have
>>>been correct. Since this is not the only possible way to construct
>>>a halt analyzer, Turing's proof is incorrect.
>>
>>True, it's not the only possible way to construct a halt analyzer.
>>False that you can construct a halt analyzer that doesn't return
>>its value.
> 
> 
> Why the hell not? It is by no means at all impossible to
> write a function that does not return a value to its caller.
> This is a standard feature of many programming languages.
> 
> 

It's possible to construct _some_ functions that don't return
their values.  It's impossible to construct a Halt Analyzer
that returns its value, because it could be trivially modified
to return its value and therefore cannot exist in the first place.

Peter Olcott wrote:
> "Kenneth Doyle" <nobody@notmail.com> wrote in message news:Xns9530930741A2Dnobodynotmailcom@61.9.191.5...
> 
>>"Peter Olcott" <olcott@worldnet.att.net> wrote in
>>news:YflMc.129177$OB3.119435@bgtnsc05-news.ops.worldnet.att.net:
>>
>>
>>>Yes, at least one of the assumptions is wrong. What about the
>>>assumption that you must return that result of the halt analysis
>>>back to the program being analyzed?
>>>
>>
>>Yes, that's a terrible assumption to make about a function that is defined
>>to return the result of the halt analysis back to the function that called
>>for the result.
> 
> 
> And it proves that no other form of halt analyzer can possibly exist?
> 
> 
No, the ability to trivially construct one from the other IF ONE EXISTS
proves that no other form of halt analyzer can exist.

"Daryl McCullough" <daryl@atc-nycorp.com> wrote in message news:cdtt2g028nt@drn.newsguy.com...
> Peter Olcott says...
>
> >Exactly how does the fact that you can corrupt one program in any
> >way effect the capability of the original uncorrupted program?
>
> Why in the world do you think that it is *corrupting* a program
> to put in a return value?

http://home.att.net/~olcott/halting/index.html#objection03

The corrupted version won't work, but, the original one
still works just fine, even if the corrupted version is used
as its input.

Donald Roby <droby@acm.org> wrote:
: On Sat, 24 Jul 2004 13:27:25 +0000, Peter Olcott wrote:

:>> I'm beginning with something that's been been proven.  You are in fact
:>> assuming that you have an analyzer that you can change so it doesn't
:>> return its value.  This assumption has been proved false.
:>>
:>> > Show me via a detailed execution trace of exactly why my reasoning is
:>> > incorrect. Point me to the exect line number where my reasoning fails.
:>> >
:>> >
:>> Execution traces of nonexistent programs are not possible.
:>>
:>> Your (partial) source code for void WillHalt:
:>>
:>> 1  void WillHalt(string SourceCode, string InputData)
:>> 2  {
:>> 3    if (TheProgramWillHalt(SourceCode, InputData))
:>> 4     SecureOutput("The Program Will Halt");
:>> 6    else if (TheProgramWillNotHalt(SourceCode, InputData))
:>> 7     SecureOutput("The Program Will Not Halt");
:>> 9    else  // This code never gets executed if the solution is properly implemented
:>> 10     SecureOutput("Security Has Been Breached, Take Corrective Action");
:>> 11  }
:>>
:>>
:>> Your reasoning fails at line #3.  It assumes the existence of
:>>
:>> bool TheProgramWillHalt(string SourceCode, string InputData)
:>>
:>> and this function was proven not to exist by Turing.
:>>
:> Close but no cigar. This function was proven to not exist by Turing
:> iff it returned its result to all callers. Since this function does not
:> return its result to all callers (it is an internal function to void WillHalt()
:> and inaccessible to all others) Turing's proof does not apply.

: A function returns its result to its caller.  This is the definition of a
: function.  This function was proven not to exist.

: If it exists as an internal function to a program, then *IT EXISTS*.  The
: very existence of such a function is precisely what Turing disproved. 
: Containment inside the context of another program is irrelevant.  If it
: exists, it can be removed from that context and stand on its own returning
: its value to whatever calls it.

: You need to go study logic.  Your confusion is entirely in the logic of
: existence, universality and implication.  It has nothing to do with
: programming.

His confusion has a lot to do with programming.  He somehow thinks you 
can write a function that cannot be copied, modified or called other than 
in the one limited way he describes.  He also thinks that ifs, whiles,
and other control structures will magically change their behavior
if you add or remove print statements.

Stephen

"Daryl McCullough" <daryl@atc-nycorp.com> wrote in message news:cdttpn02b67@drn.newsguy.com...
> Let WillHaltMod(x,y) be a program with the following behavior:
>
>      For any inputs x and y:
>      If WillHaltPO(x,y) prints "true" to the screen, then
>      WillHaltMod(x,y) returns true.
>      If WillHaltPO(x,y) prints "false" to the screen, then
>      WillHaltMod(x,y) returns false.
>
> Are you saying that it is *impossible* to construct the program
> WillHaltMod? Why doesn't the following procedure work:
>
>       1. Copy the source code for WillHaltPO.
>       2. Change the return type to boolean.

That is why it is impossible to construct WillHaltMod(x,y).
You just are not reasoning this all the way through. You
are so convinced that I must be wrong that you continue
to take the short-cut of assumptions.

Returning the result of the halt analysis to the program being
analyzed is the root of the definition of the Halting Problem.
The fact that the program being analyzed can change its
behavior (thus change the result of the analysis) based on
the return value is what makes the Halting Problem a problem.
This is why the single change of refraining from returning
that value produces a different result than when the only
difference is that the result is returned.


>       3. Search for statements of the form
>              outputToScreen(x)
>          (or whatever the syntax is)
>       4. Replace each one by "return x;"
>
> --
> Daryl McCullough
> Ithaca, NY
>

> >Yes, at least one of the assumptions is wrong. What about the
> >assumption that you must return that result of the halt analysis
> >back to the program being analyzed?
>
> That is an assumption about how TMs are defined. So if a TM is
> defined differently, then maybe you can get a solvable halting problem
> for that -new- kind of machine. But that doesn't change the fact that
> it works for the good ol' fashioned TM.
>
> Mitch

If no TM can refrain from returning the result of its computation to its caller
then the Church-Turing thesis:

Any computation that can be carried out by mechanical means can
be performed by some Turing Machine

is refuted by any C++ void function.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2mfe6qFlqlk6U3@uni-berlin.de...
> Peter Olcott <olcott@worldnet.att.net> wrote:
> >> >>An appeal to authority is very relevant when the authority
> >> >>is an expert in the field in question. In such a case, the
> >> >>appeal is not a fallacy.
> >> >
> >> > In deductive logic, it is always an error.
> >> > It becomes valid in inductive logic.
> >>
> >> OK. I'll accept that. That's a very reasonable distinction.
> >>
> >It's just the facts.
>
> If by "fact" you mean social convention. :)
>
> Mitch
>
No, fact as in tautology.

In comp.theory Peter Olcott <olcott@worldnet.att.net> wrote:

: "Marc Goodman" <marc.goodman@comcast.net> wrote in message news:mCqMc.175385$Oq2.78595@attbi_s52...
:>
:> True, it's not the only possible way to construct a halt analyzer.
:> False that you can construct a halt analyzer that doesn't return
:> its value.

: Why the hell not? It is by no means at all impossible to
: write a function that does not return a value to its caller.
: This is a standard feature of many programming languages.

Neither is it by no means at all impossible to modify a function
that prints its output to the screen to return it to the caller.

You are claiming you can write a function f1

void f1(int x)
{
    int y;
    //  
    // code to evaluate y
    //
    cout << y << endl;
}

but that it is impossible for us to write the function f2

int f2(int x)
{
    int y;
    //  
    // code to evaluate y
    //
    return y;
}

Changing the cout to a return is not going to change the
logic of the program.  Anything that can be calculated by f1
can be calculated by f2.  The following program will print the
same value twice, no matter what the 'code to evaluate y' is.

int main()
{
	f1(10);
	cout << f2(10) << endl;
}

Stephen

Peter Olcott wrote:
> http://home.att.net/~olcott/halting/index.html#objection03
> 
> The corrupted version won't work, but, the original one
> still works just fine, even if the corrupted version is used
> as its input.

Wrong again, Peter.  If void WillHalt() exists, it must correctly
answer whether any TM will halt, NOT JUST ITSELF.  I'll grant
you it can answer TRUE when applied to void WillHalt and UNKNOWN
when applied to bool WillHalt, and cannot be used _itself_ to
prove the halting problem.  However, if it existed, you could
apply it to the original TM from the halting problem.  What would
void WillHalt() say about that original TM?  Would it say that
the original TM halts when it is applied to itself, or would it
say UNKNOWN?  Because, if it says the original TM would halt, it
is broken code and is not working correctly.  But if it answers
UNKNOWN (or secure prints "Security Violation") then that's also
incorrect because the original TM has not been tampered with.

So, which is it?  What does void WillHalt() print when applied
to the original TM?

"Peter Olcott" <olcott@worldnet.att.net> wrote in message
news:9hiLc.292212$Gx4.86543@bgtnsc04-news.ops.worldnet.att.net...
|
| That's not a valid refutation either. Yes I am a
| rugged individualist. All the conformists gave up
| long ago, I guess that's why it was so easy.

Peter, rugged individualist, inventor and kook.

You have made the claim that you are a professional programmer.  If
by that you mean someone pays you to produce crap code, then I
suppose you must be.

For my own amusement, I have followed up on some more of your silly
posts in different ngs.

I nearly fell on the floor laughing when I read, by your own
admission, you cannot get even a really, really trivial program
working without help from a grown up.  Take a look at the message you
posted a couple of years ago, copied below, and the follow up.

The advice sought was duly supplied.  Even then, Peter, you had to
have the problem spelt out for you in large type.

But the best bit of all, mega ironic given your inability to
understand even the simplest of dismissals of your 'refutation' was
your reply:
  "Someone else gave me this same advice so it must be correct."

--
)>==ss$$%PARR(�>   Parr


============= start Peter's message ================
From: "Peter Olcott" <olcott@worldnet.att.net>
Newsgroups:
borland.public.cppbuilder.graphics,borland.public.cppbuilder.language
,borland.public.cppbuilder.winapi
Subject: Why does this code crash?
Date: Sat, 1 Jun 2002 15:31:20 -0500
Lines: 21
X-Priority: 3
X-MSMail-Priority: Normal
X-Newsreader: Microsoft Outlook Express 6.00.2600.0000
X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2600.0000
NNTP-Posting-Host: 12.75.102.85
Message-ID: <3cf92f0a$1_1@dnews>
X-Trace: dnews 1022963466 12.75.102.85 (1 Jun 2002 13:31:06 -0700)


http://home.att.net/~olcott/KeyHook.html

This code was derived from a fully functional example
program. Nearly all of my modifications were to the
KeyDLL.cpp file, thus this is the probable source of
error.

Although it is written using the Borland compiler, I am
sure that the reason that it crashes has to do with how
I am using the Windows API functions.

I am also nearly certain that the error is located in the
KeyDLL.cpp file. This code does exactly what it is
supposed to do for a few hundred keystrokes. After
awhile it changes to a different font,  and then ceases
to function properly, altogether.

I am guessing that this has to do with the way that I select
the font in the KeyDLL file.
============ end Peter's message ============

Later on in the thread:


============= start Peter's follow up message ================


"Micha Nelissen" <M.Nelissen@an.ti.sp.am.student.tue.nl> wrote in
message news:3cf9f19a_1@dnews...
>
> "Peter Olcott" <olcott@worldnet.att.net> wrote:
> > I am guessing that this has to do with the way that I select
> > the font in the KeyDLL file.
>
> Shouldn't you deselect the font?
>
> ---
> Line 206:
>     SelectObject(hdc, hFont);
>
> ---
>
> You should save the handle of the previously selected font, and
then before
> you deleteobject(hFont), reselect that returned font.
>
> HTH,
>
> Micha.
>

Someone else gave me this same advice so it must be correct.

Without knowing all the subtle nuances of how windows works,
one would assume that a font would remain selected, and not
need to be selected again. I can't see where I did anything to
deselect this font. Can you explain this to me?   Thanks


============ end Followup message ============

"Isaac To" <iketo2@netscape.net> wrote in message news:87k6wt4fax.fsf@sinken.local.csis.hku.hk...
> But as long as you modify your program correctly, this is not the
> case.  That is, if your program has a reasonable notion of "printing
> to the screen and terminate" to answer whether the input is a halting
> instance.  You simply modify any location of your program that prints
> to screen to check what you are printing, and if it is "yes" then you
> instead cause the WillHalt function return 1 using whatever mechanism
> available, and if it is "no" then you makes it return 0.  Then the
> modified program can be proved to have equivalent behaviour to yours,

No, this is merely a false assumption.
http://home.att.net/~olcott/halting/index.html#objection03
The whole reason that the Halting Problem is a problem in the first
place is that the halt analyzer returns its results to the program being
analyzed, and the program being analyzed changes its behavior based
on these results, which in turn changes the result of the analysis,
around and around.

If the only thing that it changed is that halt analyzer does not return
its result back to the program being analyzed, then this program
can not possibly change its behavior based on these results, thus
the results are conclusive rather than undecidable.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2mfcv1Flqlk6U1@uni-berlin.de...
> >> True, it's not the only possible way to construct a halt analyzer.
> >> False that you can construct a halt analyzer that doesn't return
> >> its value.
> >
> >Why the hell not? It is by no means at all impossible to
> >write a function that does not return a value to its caller.
> >This is a standard feature of many programming languages.
>
> Sure. But then it is not a function!
>
> Mitch

That is merely mincing words. Within mathematics it is not a
function, within C++ it is a function. I could alter my statement
merely replacing the word function with procedure, and my
essential reasoning remains the same.

"Isaac To" <iketo2@netscape.net> wrote in message news:87bri54de2.fsf@sinken.local.csis.hku.hk...
>   The halting problem for any type of machine capable of expressing
>   the Turing machine computations cannot be solved using any type of
>   machine that the Turing machine is capable of expressing.

Except that this whole line-of-reasoning falls flat on its face
once the assumption that the halt analyzer must return its result
back to the program that is being analyzed is dropped.

> Regards,
> Isaac.

"Mitch Harris" <harrisq@tcs.inf.tu-dresden.de> wrote in message news:2mfehoFlqlk6U4@uni-berlin.de...
> Peter Olcott <olcott@worldnet.att.net> wrote:
> >
> >Since it is possible to create a halt analyzer that does not
> >return its result back to the program being analyzed, then
> >Turing proof is not correct.
>
> How can that possibly follow? How does the existence of an object with
> one property deny the existence of another object with the opposite
> property?
>
> Mitch
>
>
The Turing proof requires the assumption that any halt analyzer must
return its result back to the program being analyzed. If the halt analyzer
does not return is result back to the program being analyzed, then this
proof fails.

Peter Olcott <olcott@worldnet.att.net> wrote:
>> >Yes, at least one of the assumptions is wrong. What about the
>> >assumption that you must return that result of the halt analysis
>> >back to the program being analyzed?
>>
>> That is an assumption about how TMs are defined. So if a TM is
>> defined differently, then maybe you can get a solvable halting problem
>> for that -new- kind of machine. But that doesn't change the fact that
>> it works for the good ol' fashioned TM.
>
>If no TM can refrain from returning the result of its computation to
>its caller
>then the Church-Turing thesis:
>
>Any computation that can be carried out by mechanical means can
>be performed by some Turing Machine
>
>is refuted by any C++ void function.

The existence of a void function (a function with no return value) 
doesn't change anything in the original proof. 

Mitch

"Daryl McCullough" <daryl@atc-nycorp.com> wrote in message news:cdu0ff02irt@drn.newsguy.com...
> Peter Olcott says...
>
> >The original argument relied upon the assumption that the only
> >possible way to construct a halt analyzer was to always return
> >its result to every possible caller. If this assumption was true
> >then the original proof would be correct.
>
> It didn't *assume* that that was the only way to return a value.
> That's the *definition* of what it means to "solve the halting
> problem". If you want to have a broader definition, fine---that
> doesn't invalidate Turing's proof.
>
> --
> Daryl McCullough
> Ithaca, NY
>

The proof proposes to prove this conclusion:
No program can ever be written to determine whether any arbitrary program will halt

My change to the way that the halt analyzer is implemented (by refraining from
returning the result of the halting analysis back to the program being analyzed)
makes the basis of Turing's proof cease to exist.

By merely making this one single change, the program being analyzed
can no longer change its behavior based on the return value from the
halt analyzer. Since its behavior can not change on this basis, determination
of its halting status is conclusive, rather than undecidable.

"Donald Roby" <droby@acm.org> wrote in message news:pan.2004.07.24.15.54.55.761864@acm.org...
> >> 1  void WillHalt(string SourceCode, string InputData)
> >> 2  {
> >> 3    if (TheProgramWillHalt(SourceCode, InputData))
> >> 4     SecureOutput("The Program Will Halt");
> >> 6    else if (TheProgramWillNotHalt(SourceCode, InputData))
> >> 7     SecureOutput("The Program Will Not Halt");
> >> 9    else  // This code never gets executed if the solution is properly implemented
> >> 10     SecureOutput("Security Has Been Breached, Take Corrective Action");
> >> 11  }
> >>
> >>
> >> Your reasoning fails at line #3.  It assumes the existence of
> >>
> >> bool TheProgramWillHalt(string SourceCode, string InputData)
> >>
> >> and this function was proven not to exist by Turing.
> >>
> > Close but no cigar. This function was proven to not exist by Turing
> > iff it returned its result to all callers. Since this function does not
> > return its result to all callers (it is an internal function to void WillHalt()
> > and inaccessible to all others) Turing's proof does not apply.
>
> A function returns its result to its caller.  This is the definition of a
> function.  This function was proven not to exist.

The problem is that you are not choosing your terms precisely enough.
In this case it forms the fallacy of equivocation. Turing did not ever prove
that this function can not exist. All that he showed was that in certain
circumstances it could not decide what the correct answer is. Once these
specific circumstances are eliminated, then undecidiability is also eliminated.

> If it exists as an internal function to a program, then *IT EXISTS*.  The
> very existence of such a function is precisely what Turing disproved.
> Containment inside the context of another program is irrelevant.  If it
> exists, it can be removed from that context and stand on its own returning
> its value to whatever calls it.
>
> You need to go study logic.  Your confusion is entirely in the logic of
> existence, universality and implication.  It has nothing to do with
> programming.
>

"Marc Goodman" <marc.goodman@comcast.net> wrote in message news:4102897E.7060904@comcast.net...
> Peter Olcott wrote:
> >>If void WillHalt() existed, then bool WillHalt() could be
> >>trivially constructed from void WillHalt(). bool WillHalt()
> >>cannot exist so void WillHalt() cannot exist.
> >>
> >>
> >>>Show me via a detailed execution trace of exactly why my reasoning is
> >>>incorrect. Point me to the exect line number where my reasoning fails.
> >>
> >>You can't show an execution trace for a program that cannot exist.
> >>The exact point where your reasoning fails is when you assume
> >>that void WillHalt() can exist.  It can't.
> >
> >
> > That's merely an empty unsupported claim, can't you do better than that?
> >
> >
>
> If void WillHalt() existed, bool WillHalt() could be constructed
> from it trivially.  bool WillHalt() cannot exist, therefore void
> WillHalt() cannot exist.
>

http://home.att.net/~olcott/halting/index.html#objection03