Is there something in-between?

Lately we have been goofing around a LOT with Cellular Automata and Agent-Based simulations.  Of course we're working on the Genetic Algorithms cases study, but some students have asked about other applications of these really interesting parts of computational science.

So today I was reading Cities and Complexity and came to the part where they shift from strict rule-based, deterministic cellular automata simulations, to simulations that include random elements.  I immediately remembered something that I had thought of a while back while working on some of Wolfram's one-dimensional CA studies (and then, for some reason, I completely forgot about it again until this morning).  Here's the thought:

When we think of a typical CA simulation, we use a single set of rules, like, say, Rule 110 for the one-dimensional CA that Wolfram had studied.  That rule is a strict one-to-one mapping of situation to response, so there is NO randomness at all. 

Naturally, one gets curious about what adding random elements would do to the patterns.  But then I thought of something else, and it really got me to thinking about determinism and randomness.  Let me just show you what I was thinking:

Rule 30 from Wolfram is the base 10 name for this binary mapping:

0 0 0 1 1 1 1 0

Now of course that tells each cell what to do (whether to be "on" or "off" in the next phase) for each of the eight possible situations it could be in. 

So, if we wanted to, we could randomize it by replacing one of those digits with a coin flip (f):

0 0 f 1 1 1 1 0

Here, in the third digit from the left, we have switched from "always turn off" to "turn off with a 50% chance. "  By that we mean something like, "flip a coin, dude, and heads you are on, tails you are off."

But then I remembered something I had toyed around with when thinking up some AI patterns and state machine stuff for a simple game I was working on.  What if, instead of something like "choose 1 80% of the time, chose 0 the other 20%" was handled differently?  What if we instead put an array of numbers into that particular position, with a string of results in it:

0 0 [ 1 1 1 1 0 ] 1 1 1 1 0

Now, instead of an 80% CHANCE of choosing 1, we simply tell the agent that she should respond with the number in the array--and she should increment by one each successive turn.  Meaning, using the example above, when the 3rd position in the array first comes up, she chooses 1.  She does that the 2nd, 3rd, and 4th time, also.  However, the fifth time she chooses 0.  After that she simply loops around and starts over at the beginning.  So you can see that she will choose 1 exactly 80% of the time, but there's no chance involved.  It's completely deterministic, and yet it takes the whole question of one-dimensional CA to a whole new level of, well, complexity.  Or does it?  I really haven't had much time to think about this in detail, but it seems strangely different than randomness. 

I guess what it really makes me think about is how attractive the finite set of 256 rules that Wolfram studied seemed to me at first.  How ... cozy it seemed that the structure was so, well, structured.  Now I'm thinking that there's an infinity of rules--all strictly deterministic--that could be looked at for good ol' one-dimensional CA. 

Time to hit the books....

Genetic Algorithms: Summer Fun!

Just thought I'd drop in for a second and post about what I've been up to.

Today I wrote Java code to attempt to reproduce a Genetic Algorithms study that Melanie Mitchell talks about in chapter nine of her excellent book, Complexity: A Guided Tour.

Right now I'm a little brain fried after using both Python and Java to find an easy way to convert a five digit string version of a base three number to a decimal version. Maybe you've done something similar this Summer? :-)

The project in short description is simply a way to use evolution to produce the best algorithm for a near-sighted bot that picks up cans in a large room. It's not the situation that matters as much as it is the method: Genetic Algorithms.

Image is from the Complexity page at Wikipedia.

Spring Break

The Avalon Hill Game Company made a lot of money off of me in the 80s.  I mean, I basically bought just about every sports game they published, and a heck of a lot of their other games.  While the wargames were fun (from Stalingrad to B17), I always enjoyed a good sports game.

One of the most interesting games from AH was March Madness, a game focused on the NCAA basketball tournament.  The main game was unimpressive and let you roll dice to quickly play out an entire 64 team tournament in under an hour.  But it was pretty generic and ... dull.

March Madness, however, had an "advanced game" version included that was pure brilliance.  It allowed for players to coach a team from the past final four teams (I always choose Michigan '89, of course), and you ended up with a surprisingly realistic result from an abstract system that hardly resembled a game of basketball.  But heck, even the solitaire version worked, and despite the strange system, it felt more like an authentic game of basketball than did any of the APBA or Statis-Pro simulations that took way too long to play (one game usually took five or six hours).

So, with the actual NCAA tournament on TV as background, I'm beginning an attempt to make a computer version of March Madness.  I may use Java.  I may use Python.  I guess I could even use Open Office Spreadsheet for this....  At any rate, I hope to recapture the excitement that this strange little basketball simulation brought to me back in the early 90s, when I wrote up a career mode set of rules that included recruiting and player development.