P: n/a

The Halting Problem can not be solved within the degree of
expressability of a TM. My solution only worked because of
its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is
no way to make constructing the counterexample program
impossible for a TM.  
Share this Question
P: n/a

"Peter Olcott" <ol****@worldnet.att.net> wrote in message
news:SX********************@bgtnsc05news.ops.worldnet.att.net... The Halting Problem can not be solved within the degree of expressability of a TM. My solution only worked because of its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is no way to make constructing the counterexample program impossible for a TM.
I think I already asked you to stop posting this stuff, but you appear
to have a halting problem.
Jonathan  
P: n/a

Peter Olcott wrote: The Halting Problem can not be solved within the degree of expressability of a TM. My solution only worked because of its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is no way to make constructing the counterexample program impossible for a TM.
This is either a much better forgery than last time, or a
very surprising turn of events.  
P: n/a

"Jonathan Turkanis" <te******@kangaroologic.com> wrote in message news:2m************@uniberlin.de... "Peter Olcott" <ol****@worldnet.att.net> wrote in message news:SX********************@bgtnsc05news.ops.worldnet.att.net... The Halting Problem can not be solved within the degree of expressability of a TM. My solution only worked because of its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is no way to make constructing the counterexample program impossible for a TM.
I think I already asked you to stop posting this stuff, but you appear to have a halting problem.
Jonathan
Well it looks like I am wrong that I am wrong again.
This time I won't bother with anything less than a full
refutation of the original proof. I do have a basis for
disproving the original proof.  
P: n/a

"Marc Goodman" <ma**********@comcast.net> wrote in message news:pgTMc.184435$XM6.144686@attbi_s53... Peter Olcott wrote: The Halting Problem can not be solved within the degree of expressability of a TM. My solution only worked because of its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is no way to make constructing the counterexample program impossible for a TM.
This is either a much better forgery than last time, or a very surprising turn of events.
It is a very surprising turn of events. There was one message
That I read this morning that got me thinking. After I thought
about it I realized that my solution would not apply to Turing
Machines. Not that my solution required something more than
a Turing Machine, but something less. My solution required
data hiding that is not available on a Turing Machine. One
thing that the results in is the fact that I did not (yet) correctly
refute, or solve the original Halting Problem.
A solution such as the one that I was proposing would have probably
been obvious to Turing, long ago, if these features would have been
invented at the time. So it is not exactly that my solution is wrong,
it is still right in a sense. It is more along the lines that it is of much
less consequence that I had hoped.
I do have a whole other solution in mind. It merely requires the
application of ideas that I already posted. I think that I can still
disprove the original Halting Problem. It does look like it would
be a waste of time to provide anything less than a direct frontal
attack on the original proof. In it current form no one would accept
it.
I will post it in another thread anyway, just to get on record
as this idea's originator.  
P: n/a

In sci.logic, Peter Olcott
<ol****@worldnet.att.net>
wrote
on Sun, 25 Jul 2004 18:26:58 GMT
<SX********************@bgtnsc05news.ops.worldnet.att.net>: The Halting Problem can not be solved within the degree of expressability of a TM. My solution only worked because of its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is no way to make constructing the counterexample program impossible for a TM.
Well, the following TM:
StartState: S
HaltState: H
Alphabet: [AZaz09_]
TransitionFunction:
From: S
With: *
To: H
Moving: Sit
will probably be as close to a void function as one can allow. :)

#191, ew****@earthlink.net
It's still legal to go .sigless.  
P: n/a

Peter Olcott wrote: "Marc Goodman" <ma**********@comcast.net> wrote in message news:pgTMc.184435$XM6.144686@attbi_s53... Peter Olcott wrote: The Halting Problem can not be solved within the degree of expressability of a TM. My solution only worked because of its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is no way to make constructing the counterexample program impossible for a TM.
This is either a much better forgery than last time, or a very surprising turn of events. It is a very surprising turn of events.
Not really.
Peter, you are on a completely wrong track.
For one thing there is the claim of the so called 'Halting Problem':
No such function can exist.
And then there is the proof for this claim:
Based on the assumption that such a function exists, it can be shown
that this assumption leads to a contradiction: namely that the function
cannot exist.
But note: The proof you are attacking is based on the *assumption* that
such a function exists.
So when you attack the proof, and turn it around, all you end up with is:
Based on the assumption that such a function exists, that function can be
written.
That's not nearly of the same quality as the original proof. If I assume
the moon consists of chesse, then I can conclude that the moons material
is cheese. Fine. It's all based on the assumption. But: If I can proove
that even if I assume that the moon is made of cheese the only conclusion
is that it is not made of cheese, I have shown something important: No matter
what I do or assume, the moon cannot be made of cheese.
You should familiarize yourself with proofing methods in a better way. The
type of proof used for prooving that Halting problem can only be used to
show that X does not exist. It always works the same way
* 1) assume X
* 2) show that assuming X leads to a contradiction. You can use X in that
proof
* 3) only logical conclusion: > X cannot be assumed
If you need to show that X really exists, you need a different type of proof.
Just fighting step 2) in the above is not enough.

Karl Heinz Buchegger kb******@gascad.at  
P: n/a

"Karl Heinz Buchegger" <kb******@gascad.at> wrote in message news:41***************@gascad.at... Peter Olcott wrote: For one thing there is the claim of the so called 'Halting Problem': No such function can exist.
So as soon as I show that there is a way to make such a function this proof
has been refuted.
And then there is the proof for this claim: Based on the assumption that such a function exists, it can be shown that this assumption leads to a contradiction: namely that the function cannot exist.
I can show that it does not lead to a contradiction.
That it leads to a contradiction is a conclusion that does not follow
from the proof.
But note: The proof you are attacking is based on the *assumption* that such a function exists.
So when you attack the proof, and turn it around, all you end up with is: Based on the assumption that such a function exists, that function can be written.
I end up with the fact that the proof that shows that it is impossible
is incorrect. This by itself is an amazing feat. No one has even
questioned this proof for 68 years. They all accept it as fact.
I can't proof that a program can be written to determine if every other
program halts. I can show the the proof that this can not be done
is incorrect. This thread's title indicates that my prior efforts did
mnot address the original proof, because these prior efforts can
not be implemented as a Turing Machine. I have another method
that can be implemented as a Turing Machine.
Karl Heinz Buchegger kb******@gascad.at  
P: n/a

Peter Olcott wrote:
But note: The proof you are attacking is based on the *assumption* that such a function exists.
So when you attack the proof, and turn it around, all you end up with is: Based on the assumption that such a function exists, that function can be written. I end up with the fact that the proof that shows that it is impossible is incorrect.
The last time: You did not.
What you did is: you modified the proof.
But there is nothing wrong with the original proof. All its steps
are correct.
This by itself is an amazing feat. No one has even questioned this proof for 68 years.
Thats because the proof is correct.
They all accept it as fact. I can't proof that a program can be written to determine if every other program halts. I can show the the proof that this can not be done is incorrect.
No you cannot. In order to show this, you *have to leave the proof
as it is*. No modifications allowed. As soon as you modify the proof
you are no longer proving or disproving the proof. You are proving
or disproving something else.
I will not respond any longer.

Karl Heinz Buchegger kb******@gascad.at  
P: n/a

Peter Olcott wrote: No one has even questioned this proof for 68 years.
I recommend reading
Douglas R. Hofstadter
Goedel, Escher, Bach
The whole book turns around Goedels famous proof.
In fact the Halting Problem and the way it is proofed
is just a variation of Hilberts Problem and the way Goedel
put it to an end. The book extends this and shows how
this has implications and what can be learned from it
in various other disciplines which range from computers
to biology.
And: While it is not an easy read (at least it wasn't for me),
it is still fun to read and I would count it as one of the
most important books I have ever read.

Karl Heinz Buchegger kb******@gascad.at  
P: n/a

Peter Olcott <ol****@worldnet.att.net> wrote: is incorrect. This by itself is an amazing feat. No one has even questioned this proof for 68 years. They all accept it as fact.
You don't have much idea of what 'reading a proof' entails,
do you? You go in waiting to be persuaded, and when you've
finished reading it you understand why it's correct. That's
kind of the point of proofs, you see.
I can't proof that a program can be written to determine if every other program halts.
Correct. (Because no such program can exist.)
I can show the the proof that this can not be done is incorrect.
Incorrect. There are various correct proofs that the
halting problem is unsolvable available in undergraduate
text books. In fact, it's not even clear to me just
*which* proof you claim to be incorrect; I saw at least
one correct proof posted in response to you.

Rob. http://www.mis.coventry.ac.uk/~mtx014/  
P: n/a

You got it Peter! Very good!
"Peter Olcott" <ol****@worldnet.att.net> wrote in message
news:SX********************@bgtnsc05news.ops.worldnet.att.net... The Halting Problem can not be solved within the degree of expressability of a TM. My solution only worked because of its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is no way to make constructing the counterexample program impossible for a TM.  
P: n/a

Peter Olcott wrote: It is a very surprising turn of events. There was one message That I read this morning that got me thinking. After I thought about it I realized that my solution would not apply to Turing Machines. Not that my solution required something more than a Turing Machine, but something less.
That much is right. A model of computation *less* powerful than
Turing's may admit a program that decides the model's halting
problem. Halting is undecidable in any programming language that
is 'complete' in the sense of the ChurchTuring thesis.

Bryan  
P: n/a

"Bryan Olson" <br***********************@yahoo.com> wrote in message news:1a*************************@posting.google.co m... Peter Olcott wrote: It is a very surprising turn of events. There was one message That I read this morning that got me thinking. After I thought about it I realized that my solution would not apply to Turing Machines. Not that my solution required something more than a Turing Machine, but something less.
That much is right. A model of computation *less* powerful than Turing's may admit a program that decides the model's halting problem. Halting is undecidable in any programming language that is 'complete' in the sense of the ChurchTuring thesis.
 Bryan
Well on to my proof of that case.  
P: n/a

"Anonymous" <an*******@home.net> wrote in message news:4H*****************@newssvr32.news.prodigy.co m... You got it Peter! Very good!
"Peter Olcott" <ol****@worldnet.att.net> wrote in message news:SX********************@bgtnsc05news.ops.worldnet.att.net... The Halting Problem can not be solved within the degree of expressability of a TM. My solution only worked because of its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is no way to make constructing the counterexample program impossible for a TM.
Except that I have now figured out how to solve it for Turing Machines
with a Turing Machine. See my newest thread.  
P: n/a

"Peter Olcott" <ol****@worldnet.att.net> wrote: Well on to my proof of that case.
Why bother? No one cares about that case.
xanthian.

Posted via Mailgate.ORG Server  http://www.Mailgate.ORG  
P: n/a

"Peter Olcott" <ol****@worldnet.att.net> wrote: Except that I have now figured out how to solve it for Turing Machines with a Turing Machine. See my newest thread.
No, you didn't, and just as in the case of your
former bogus proof, no one needs to look at your
current bogus proof to know otherwise.
I'm sure you will spend another month or so calling
all the people who understand what it means that the
task you are claiming to have accomplished, has been
proved to be impossible to accomplish, nasty names
for trusting that entirely lucid, easily understood
proof over your obfuscated muddle of a nonproof,
again.
You'll eventually find out you are wrong, again.
You'll have learned nothing, as you learned nothing
this time, and set off down the same barricaded
path, again, no doubt.
That's why what you have is called "INVINCIBLE
ignorance"; nothing short of death can cure it.
xanthian.

Posted via Mailgate.ORG Server  http://www.Mailgate.ORG  
P: n/a

In message <Ht*******************@bgtnsc05news.ops.worldnet.att.net>,
Peter Olcott <ol****@worldnet.att.net> writes "Jonathan Turkanis" <te******@kangaroologic.com> wrote in message news:2m************@uniberlin.de... "Peter Olcott" <ol****@worldnet.att.net> wrote in message news:SX********************@bgtnsc05news.ops.worldnet.att.net... > The Halting Problem can not be solved within the degree of > expressability of a TM. My solution only worked because of > its more limited degree of expressability. > > There is no such thing as a void function in a TM, thus there is > no way to make constructing the counterexample program > impossible for a TM.
I think I already asked you to stop posting this stuff, but you appear to have a halting problem.
Well it looks like I am wrong that I am wrong again. This time I won't bother with anything less than a full refutation of the original proof. I do have a basis for disproving the original proof.
Do you know James Harris?

Richard Herring  
P: n/a

"Bryan Olson" <br***********************@yahoo.com> wrote in message
news:1a*************************@posting.google.co m... Peter Olcott wrote: It is a very surprising turn of events. There was one message That I read this morning that got me thinking. After I thought about it I realized that my solution would not apply to Turing Machines. Not that my solution required something more than a Turing Machine, but something less.
That much is right. A model of computation *less* powerful than Turing's may admit a program that decides the model's halting problem. Halting is undecidable in any programming language that is 'complete' in the sense of the ChurchTuring thesis.
Moreover, a language that admits a program that decides the halting problem
cannot be powerful enough to program its own interpreter.  
P: n/a

"Peter Olcott" <ol****@worldnet.att.net> wrote in message
news:5%*********************@bgtnsc04news.ops.worldnet.att.net... That much is right. A model of computation *less* powerful than Turing's may admit a program that decides the model's halting problem. Halting is undecidable in any programming language that is 'complete' in the sense of the ChurchTuring thesis.
Well on to my proof of that case.
The trouble is that a computational model that is restricted enough to allow
the halting problem to be proved is not very useful. In particular, any
programming language that conforms to such a computational model cannot be
strong enough to program an interpreter for its own language.  
P: n/a

"Andrew Koenig" wrote: "Bryan Olson" wrote: A model of computation *less* powerful than Turing's may admit a program that decides the model's halting problem. Halting is undecidable in any programming language that is 'complete' in the sense of the ChurchTuring thesis.
Moreover, a language that admits a program that decides the halting problem cannot be powerful enough to program its own interpreter.
There are arguable vacuous cases where that doesn't hold.
Suppose I define a computational language such that for any
program and any input, it outputs 'true'. Now if I define an
encoding of pairsofstrings to stings, to represent (Machine,
Input), I can claim *any* program is an interpreter, because for
any P, P(Machine, Input) produces the same result as
Machine(Input). What's more, it solves it's halting problem,
since 'true' describes the machine's haltingbehavior for any
input.

Bryan  
P: n/a

"Bryan Olson" <br***********************@yahoo.com> wrote in message
news:1a*************************@posting.google.co m... "Andrew Koenig" wrote: "Bryan Olson" wrote: A model of computation *less* powerful than Turing's may admit a program that decides the model's halting problem. Halting is undecidable in any programming language that is 'complete' in the sense of the ChurchTuring thesis.
Moreover, a language that admits a program that decides the halting
problem cannot be powerful enough to program its own interpreter.
There are arguable vacuous cases where that doesn't hold. Suppose I define a computational language such that for any program and any input, it outputs 'true'. Now if I define an encoding of pairsofstrings to stings, to represent (Machine, Input), I can claim *any* program is an interpreter, because for any P, P(Machine, Input) produces the same result as Machine(Input). What's more, it solves it's halting problem, since 'true' describes the machine's haltingbehavior for any input.
One might argue that in such a language, it is meaningless to talk about
determining whether a program halts, because every program in that language
halts. Hence, no determination is possible.  
P: n/a

"Andrew Koenig" <ar*@acm.org> wrote in message news:5w******************@bgtnsc04news.ops.worldnet.att.net... "Bryan Olson" <br***********************@yahoo.com> wrote in message news:1a*************************@posting.google.co m... Peter Olcott wrote: It is a very surprising turn of events. There was one message That I read this morning that got me thinking. After I thought about it I realized that my solution would not apply to Turing Machines. Not that my solution required something more than a Turing Machine, but something less.
That much is right. A model of computation *less* powerful than Turing's may admit a program that decides the model's halting problem. Halting is undecidable in any programming language that is 'complete' in the sense of the ChurchTuring thesis.
Moreover, a language that admits a program that decides the halting problem cannot be powerful enough to program its own interpreter.
That is simply not true. My C++ void function did indeed solve
any halting problem that allows void functions.  
P: n/a

Peter Olcott wrote: That is simply not true. My C++ void function did indeed solve any halting problem that allows void functions.
False. Not only was the function never shown, when Peter said
what it determines in a case I asked about, it got the answer
wrong. See: http://www.google.com/groups&selm=v2...ws.prodigy.com

Bryan  
P: n/a

"The Ghost In The Machine" <ew***@aurigae.athghost7038suus.net> wrote in message news:3r************@lexi2.athghost7038suus.net... In sci.logic, Peter Olcott <ol****@worldnet.att.net> wrote on Sun, 25 Jul 2004 18:26:58 GMT <SX********************@bgtnsc05news.ops.worldnet.att.net>: The Halting Problem can not be solved within the degree of expressability of a TM. My solution only worked because of its more limited degree of expressability.
There is no such thing as a void function in a TM, thus there is no way to make constructing the counterexample program impossible for a TM.
Well, the following TM:
StartState: S HaltState: H Alphabet: [AZaz09_] TransitionFunction:
From: S With: * To: H Moving: Sit
I don't get this last part: Moving Sit? will probably be as close to a void function as one can allow. :)
 #191, ew****@earthlink.net It's still legal to go .sigless.  
P: n/a

In sci.logic, Peter Olcott
<ol****@worldnet.att.net>
wrote
on Sun, 01 Aug 2004 03:35:36 GMT
<cy*********************@bgtnsc04news.ops.worldnet.att.net>: "The Ghost In The Machine" <ew***@aurigae.athghost7038suus.net> wrote in message news:3r************@lexi2.athghost7038suus.net... In sci.logic, Peter Olcott <ol****@worldnet.att.net> wrote on Sun, 25 Jul 2004 18:26:58 GMT <SX********************@bgtnsc05news.ops.worldnet.att.net>: > The Halting Problem can not be solved within the degree of > expressability of a TM. My solution only worked because of > its more limited degree of expressability. > > There is no such thing as a void function in a TM, thus there is > no way to make constructing the counterexample program > impossible for a TM. > Well, the following TM:
StartState: S HaltState: H Alphabet: [AZaz09_] TransitionFunction:
From: S With: * To: H Moving: Sit
I don't get this last part: Moving Sit?
Turing machines can do three things with their head per cycle:
Left
Right
Sit
The Left and Right should be obvious, and now hopefully Sit is, too. :)
If you have a better suggestion for the notion, by
all means speak up. IMO, "StayPut" is a bit clumsy.
"SameCell" is equally clumsy but might work. "None"
is a bit too generic.
As you well know, the transition function has domain
State x Alphabet and range State x Alphabet x {Left, Right, Sit}.
This means I erred slightly in the specification, which can
be handwavedaround a bit by a syntax such as
'Write: Same'
or
'Write: No'
(as opposed to 'Write: A' or 'Write: Blank')
But hopefully the idea's clear, regardless;
this machine transitions once and then halts. will probably be as close to a void function as one can allow. :)
 #191, ew****@earthlink.net It's still legal to go .sigless.

#191, ew****@earthlink.net
It's still legal to go .sigless.  
P: n/a

"The Ghost In The Machine" <ew***@aurigae.athghost7038suus.net> wrote in message news:7u************@lexi2.athghost7038suus.net... In sci.logic, Peter Olcott Well, the following TM:
StartState: S HaltState: H Alphabet: [AZaz09_] TransitionFunction:
From: S With: * To: H Moving: Sit
I don't get this last part: Moving Sit?
Turing machines can do three things with their head per cycle:
Left Right Sit
The Left and Right should be obvious, and now hopefully Sit is, too. :)
If you have a better suggestion for the notion, by all means speak up. IMO, "StayPut" is a bit clumsy. "SameCell" is equally clumsy but might work. "None" is a bit too generic.
At each step of every state transition only specify those actions
actually taken. If the head is not moved then simply don't mention
the head.  
P: n/a

The Ghost In The Machine wrote:
[...] Turing machines can do three things with their head per cycle:
Left Right Sit
The Left and Right should be obvious, and now hopefully Sit is, too. :)
If you have a better suggestion for the notion, by all means speak up. IMO, "StayPut" is a bit clumsy. "SameCell" is equally clumsy but might work. "None" is a bit too generic.
How about { Left, Right, Here }? It looks more parallel to me
(in the writer's sense, not the mathematician's).
You could also say { MoveLeft, MoveRight, StayHere }, but it's
longer, even redundant, given the category name is Moving.
Jim Burns  
P: n/a

In sci.logic, Peter Olcott
<ol****@worldnet.att.net>
wrote
on Sun, 01 Aug 2004 16:45:06 GMT
<m6*********************@bgtnsc04news.ops.worldnet.att.net>: "The Ghost In The Machine" <ew***@aurigae.athghost7038suus.net> wrote in message news:7u************@lexi2.athghost7038suus.net... In sci.logic, Peter Olcott
>> Well, the following TM: >> >> StartState: S >> HaltState: H >> Alphabet: [AZaz09_] >> TransitionFunction: >> >> From: S >> With: * >> To: H >> Moving: Sit > > I don't get this last part: Moving Sit?
Turing machines can do three things with their head per cycle:
Left Right Sit
The Left and Right should be obvious, and now hopefully Sit is, too. :)
If you have a better suggestion for the notion, by all means speak up. IMO, "StayPut" is a bit clumsy. "SameCell" is equally clumsy but might work. "None" is a bit too generic.
At each step of every state transition only specify those actions actually taken. If the head is not moved then simply don't mention the head.
AFAIK, the range is State x Alphabet x Movement, in the standard text.
One could of course use as the range of the transition function:
State union (State x Alphabet) union (State x Alphabet x {Left, Right})
if one wishes, but that's a bit harder to prove stuff with.
The domain, as always, is State x Alphabet.
Not that it matters; you're caught at the moment in an
irrelevancy. This will not help your proof that denying
WillHalt()'s information to LoopIfHalts() will somehow
invalidate Turing's Halting Impossibility Proof.

#191, ew****@earthlink.net
It's still legal to go .sigless.  
P: n/a

In sci.logic, Jim Burns
<bu******@osu.edu>
wrote
on Sun, 01 Aug 2004 13:49:16 0400
<41***************@osu.edu>:
The Ghost In The Machine wrote: [...] Turing machines can do three things with their head per cycle:
Left Right Sit
The Left and Right should be obvious, and now hopefully Sit is, too. :)
If you have a better suggestion for the notion, by all means speak up. IMO, "StayPut" is a bit clumsy. "SameCell" is equally clumsy but might work. "None" is a bit too generic.
How about { Left, Right, Here }? It looks more parallel to me (in the writer's sense, not the mathematician's).
You could also say { MoveLeft, MoveRight, StayHere }, but it's longer, even redundant, given the category name is Moving.
Jim Burns
An interesting suggestion, though I'm not sure "Here" makes as
much sense as "Sit". I was merely constructing a machine
which was the Turing Machine equivalent of a noop. :)

#191, ew****@earthlink.net
It's still legal to go .sigless.  
P: n/a

The Ghost In The Machine wrote:
[...] An interesting suggestion, though I'm not sure "Here" makes as much sense as "Sit". I was merely constructing a machine which was the Turing Machine equivalent of a noop. :)
There is a discussion of obscurity of math expressions currently
in sci.math. Keeping that in mind, I would like to offer these:
instead of ( Right, Left, Sit ) , how about ( Gee, Haw, Whoa )?
Actually, decrement, increment, and nooperation (Dec, Inc, Nop)
seem like it's almost as good a choice. (There may be a problem
with it not being obscure enough.)
Jim Burns  
P: n/a

In sci.logic, Jim Burns
<bu******@osu.edu>
wrote
on Sun, 01 Aug 2004 21:45:30 0400
<41***************@osu.edu>: The Ghost In The Machine wrote: [...] An interesting suggestion, though I'm not sure "Here" makes as much sense as "Sit". I was merely constructing a machine which was the Turing Machine equivalent of a noop. :)
There is a discussion of obscurity of math expressions currently in sci.math. Keeping that in mind, I would like to offer these: instead of ( Right, Left, Sit ) , how about ( Gee, Haw, Whoa )?
Actually, decrement, increment, and nooperation (Dec, Inc, Nop) seem like it's almost as good a choice. (There may be a problem with it not being obscure enough.)
Jim Burns
DEC = Digital Equipment Corporation
INC = Incorporated
NOP = Not Our Problem.
:)
Unfortunately for you, I've read _White Fang_, so am at least
somewhat aware of Gee, Haw, MUSH. :) (Woah is a logical
extension, and anyone who's read cowboy novels  or for that
matter seen Sylvester Sam trying to stop a camel or "stupid
dragon"  knows the meaning thereof.)
But if one wants obscure, try 1, 0, +1. Then again, that's
probably way too clear to mathematicians...

#191, ew****@earthlink.net
It's still legal to go .sigless.   This discussion thread is closed Replies have been disabled for this discussion.   Question stats  viewed: 1641
 replies: 31
 date asked: Jul 22 '05
