McCarthy's Ambiguous Operator
Back in 1961, John McCarthy (the inventor of LISP) described an
interesting mathematical operator called amb
. Essentially,
amb
hates to be called with no arguments, and can look
into the future to keep that from happening. Here’s how it might look in
Ruby.
# amb will (appear to) choose values
# for x and y that prevent future
# trouble.
x = amb 1, 2, 3
y = amb 4, 5, 6
# Ooops! If x*y isn't 8, amb would
# get angry. You wouldn't like
# amb when it's angry.
amb if x*y != 8
# Sure enough, x is 2 and y is 4.
puts x, y
Of course, amb
can’t actually see the future. However, it
can rewind into the past whenever it sees trouble, and try a
different coice.
So, how could we implement this function? As it turns out, we need continuations. Here’s a basic implementation in Ruby.
# A list of places we can "rewind" to
# if we encounter amb with no
# arguments.
$backtrack_points = []
# Rewind to our most recent backtrack
# point.
def backtrack
if $backtrack_points.empty?
raise "Can't backtrack"
else
$backtrack_points.pop.call
end
end
# Recursive implementation of the
# amb operator.
def amb *choices
# Fail if we have no arguments.
backtrack if choices.empty?
callcc {|cc|
# cc contains the "current
# continuation". When called,
# it will make the program
# rewind to the end of this block.
$backtrack_points.push cc
# Return our first argument.
return choices[0]
}
# We only get here if we backtrack
# using the stored value of cc,
# above. We call amb recursively
# with the arguments we didn't use.
amb *choices[1...choices.length]
end
# Backtracking beyond a call to cut
# is strictly forbidden.
def cut
$backtrack_points = []
end
If you’d like a fun, non-technical overview of continuations, see the explanation at RubyGarden.
Want to contact me about this article? Or if you're looking for something else to read, here's a list of popular posts.
Dan Piponi
wrote on Feb 22, 2006:
I have an implementation of "amb" that can be used in C here. Thanks for giving a name to this operator for me - I never knew what to call it.
Ben
wrote on Jan 17, 2007:
Thats really interesting.
It means that you could write a constraint DSL in Ruby or any other language which implements continuations. I thought constraint engines were hard...
Cheers
Ben
Ben
wrote on Jan 17, 2007:
Wow, I just implemented the send+more=money solver with amb:
Amb is pretty cool!
Ben
Eric Kidd
wrote on Jan 21, 2007:
Wow! That's very cool.
If you're into constraint languages, you might also enjoy Oz, which can do heavily-optimized searches of constraint problems.
The big advantage of Oz: Before choosing which path to investigate, it tries to infer as much information as possible (aka "propagation"). And then it makes very intelligent guesses about exactly which "guess" to make next (aka "distribution").
Since a backtracking search takes O(2^N) time (yikes!), it's worth doing a _lot_ of work before actually branching.
And the most popular implementation of Oz can actually spread the search over an entire cluster of computers!
Christian Theil Have
wrote on Jun 08, 2007:
"Since a backtracking search takes O(2^N) time (yikes!), it’s worth doing a lot of work before actually branching."
This really depends on the nature of the problem. If you are only going to backtrack a little, it might not be worth spend cycles on forward-checking or ensuring arc consistency. Propagation can also be quite costly.
But sure, in most cases, amb is not a very efficient way solving constraint problems..
Doug Auclair
wrote on Nov 28, 2007:
@Christian, you are quite right! For this particular problem (SEND+MORE=MONEY), eliminated selected digits narrows the search-space considerably, speeding up the calculation by a factor of ~50:
http://www.cotilliongroup.com/arts/DCG.html
(done with Prolog's definite clause grammars, which have a similar feel to Haskell's monads)
And, I suppose, one can use, e.g., Gwydion Dylan's matrix library (http://www.opendylan.org/gdref/gdlibs/libs-matrix-operations.html), along the lines of a gausse-jordan elimination, to solve the system of equations linearly? Perhaps not apropos to this problem, but handles several kinds of constraint problems.
Doug Auclair
wrote on Nov 29, 2007:
The Haskell version of SEND+MORE=MONEY in the amb-style:
... note that a definition for amb is unnecessary, as list compression (as a MonadPlus) already makes choice.
The above, as already pointed out, is not very efficient, so using a state monad to narrow the selection in-place:
splits, choose, and verify are thanks to Dirk Thierbach on comp.lang.haskell. This version is 200x faster than the amb-style one -- 10x speed up for redundant digit elimination and on top of that a 20x speed up from placing the guards as far up in the computation as possible. Although it requires some helper functions to implement nondeterminism with elimination, sendmory' retains the declarative feel of it's amb-styled counterpart.
backtrack
wrote on Sep 09, 2008:
There's also goal directed computation as implemented in the Icon language, though you probably know about it.
person-b
wrote on Jul 03, 2009:
This reminds me of Damian Conway's Positronic::Variables CPAN Perl module. He wrote it for his (hilarious - highly recommended) talk on "Temporally Quaquaversal Virtual Nanomachine Programming In Multiple Topologically Connected Quantum-Relativistic Parallel Timespaces...Made Easy!" (http://blip.tv/file/1145545/). It actually did look into the future.