One thing I know and that is that I know nothing.
- Socrates
I've been reading "Gödel, Escher and Bach: An Eternal Golden Braid"
by Douglas R. Hofstadter for kicks.
It was on my Girlfriend's bookcase, it's Big and Thick - enough reason for
me to read anything.
In one of the first chapters, it has a sort of puzzle to solve, that I will
describe below. I like puzzles. We'll call it, the "MU" puzzle for
lack of a better name. In simplified terms, you start with a string of words,
in this case, we get to start with, "MIU" and with four different
thingies, called rules, we want to try to change the string, "MIU",
to "MU". Neat. Here are the rules:
-
If any string ends in I, you can append U
Example: MUI -> MUIU
-
If any string begins with M, you can duplicate the string after M,
Example: MUI -> MUIUI
-
If any string contains III, you can replace the III with U
Example: MUIII -> MUU
-
If any string contains UU, you can delete the UU
Example:
MIUU -> MI
So, beginning with, "MUI", we can use any of these rules, in any
order, for as many times as we like to transform "MUI" into, "MU".
Well, can it be done? It seems simple enough; similar to a RubikÔ³ cube. If
you fiddle about with it enough, something is sure to come about.
Since I'm lazy, I created a simple program, written in Perl to do the task
for me. Perl stands for, Practical
Extraction and Reporting Language,
although it is never written as an acronym. Basically, it's perfect for taking
thingies in, twiddling them about and sputtering something back.
The little program I made goes through every possible way of solving this
problem recursively. It's similar to guessing a password by trying every single
combination of letters and numbers, starting with, "a" and working
from there.
It's the stupidest way of solving a problem, but computers are real smart
at being stupid - and fast. Here's the listing of what the program looks like:
#!/usr/bin/perl -w
use strict;
my %tried = ();
main();
sub main {
my @rules = (
\&rule_one,
\&rule_two,
\&rule_three,
\&rule_four,
);
my $axiom = 'MI';
my @path;
my @tries;
solve($axiom, \@rules);
}
sub solve {
my @app;
my ($axiom, $rules) = @_;
my $i = 0;
foreach(@$rules){
my $tmp = $_->($axiom);
push(@app, $tmp) if $tmp;
}
foreach(@app){
next if $tried{$_};
next unless (length($_) < 1000);
print $_ . "\n";
$tried{$_} = 1;
if($_ eq 'MU'){
print "YES!\n\n\n";
exit;
}
solve($_, $rules);
}
}
sub rule_one {
# If any string ends in I, you can append U
my $str = shift;
if ($str =~ m/I$/){
return $str . 'U';
}else{
return undef;
}
}
sub rule_two {
# If any string begins with M,
# you can duplicate the string after M,
my $str = shift;
if($str =~ /^M/){
return 'M' . substr($str, 1) . substr($str, 1);
}else{
return undef;
}
}
sub rule_three {
# If any string contains III,
# you can replace the III with U
my $str = shift;
if($str =~ /III/){
$str =~ s/III/U/g;
return $str;
}else{
return undef;
}
}
sub rule_four {
#If any string contains UU,
# you can delete the UU
my $str = shift;
if($str =~ /UU/){
$str =~ s/UU//g;
return $str;
}else{
return undef;
}
Running this program takes less than a second and never comes to a conclusion.
In all, it goes through 506 different tries in an attempt to get to the string,
"MU".
Now, I'll come clean. I did put limitations into the program. One limitation
I put in was to not attempt to try to solve the problem if using a rule creates
the same string as what had been created before. This is more of an optimization
– if we’ve figur’d something ain’t hot, let’s
not beat the dead thing.
The second limitation was to limit how large the string was to 1000 characters
- not quite every single possibility, but enough to give me a good Idea.
For kicks, I changed the size the string could be to 1,000,000
characters and ran the program again. It took about the length of time one with
a relatively short attention span (i.e. Me) could stand, plus the act of asking
and receiving a bagel at the local coffee shop (toasted) and innocently flirting
with a friend of a friend before coming back to my laptop.
In total, the program then created 505 Megabytes worth of results, but only
3338 unique incorrect outcomes to the solution. Again, I couldn't find a way
to get to, "MU". I'm somewhat at the limits on what I want to torture
my laptop at, so I'm fairly sure there's no way to get, "MU", given
the rules I've been given - yet it's quite possible that there isn't a way
to actually test this to completion!
Being lazy (again) I double checked my work with someone more smarterer than
myself and they came to the same conclusion, using Number Theory, which I
really know, nothing about (officially, as in, "I officially don't live
in my painting studio")
This is somewhat unnerving to myself: I ran a determinate test to see if something
is true and have come to a conclusion that I think I know what I’m talking
about, but have no real way of making absolutely sure without being given infinity
as a timeframe. I have determinately found something indeterminate. Well, why
is that so important?
I created a series of paintings that somewhat deals with the idea of Free Will
in a determinant system. Each one of three paintings had six different paths
created using, like the “MU” problem, a bunch of simple rules. I
saw each path as a lifespan; the longer the path, the longer the life.
Points were put upon the canvas, with which you can connect to make paths
(lines). You started drawing these lines from the perimeter of the canvas
and continued inside. You could not make a path cross itself and you could
not have a path go again outside of the canvas (something akin to suicide
in my painting).
As the path was created, random choices were made as to which point the path
should go next in the canvas. Inevitably, the path would knot itself up and
have nowhere to go and essentially, 'Dies'. Here's just one path, for clarity:
In this example, the path is"birthed" in the bottom left and "dies"
in the top left.
My whole idea was that there was no way, given the previous steps, to know
how "old" a life path would be. Thus, any decision you made, except
completely obvious decisions like jumping off a cliff (or drawing off the canvas),
would not have an affect on your future. In other words you have no real
choice; no real free will.
I personally feel a bit silly having a computer program act as a model
on how reality may be unfolding in my mind Î and perhaps thatÔ³ the point. My
free will and this determinacy may be somewhat like of apples and oranges.
Free will is not indeterminacy and thus, isnÔ´ the opposite of determinacy.
It's difficult for me, at present, to make complete sense to my own self on
all this; but I leave you with this quote, as it will be what I will be thinking
of this night:
"Now you receive all your ideas; therefore you receive your wish,
you wish therefore necessarily. The word "liberty" does not therefore
belong in any way to your will.
You ask me how thought and wish are formed in
us. I answer you that I have not the remotest idea. I do not know how ideas
are made any more than how the world was made. All that is given to us is
to grope for what passes in our incomprehensible machine.
The will, therefore, is not a faculty that one can
call free. A free will is an expression absolutely void of sense, and what
the scholastics have called will of indifference, that is to say willing without
cause, is a chimera unworthy of being combated."
-Voltaire
Bibliography
Hofstadter, Douglas R. Gödel, Escher, Bach: An Eternal Golden Braid.
Vintage Books. New York, New York. 33 Î 41.
Wegener, Daniel M. The Illusion of Conscious Will. The MIT Press.
Cambridge, Massachusetts. 2002. 317 Î 325.
Arouet Voltaire, Francois-Marie. Philosophical Dictionary. ISBN: 0766154696