Help
Choose a start position
In the top of the "parameters" tab, you can choose either a classic
start position (a n-spot game), or a free start position.
If you only have a figure of your free start position, you need to determine
its string representation as follows :
First of all, notice that this position determines 5 regions in the
plane, one of them isn’t bounded. The two regions on the left are
isolated from the 3 others, so we’ll divide this position into 2 lands
: the end-of-land character is “]”, the end-of-position character is
“!”, so the representation will be something like : “land1]land2]!”.
The end-of-region character is “}”, so we’ll have “R1}R2}]R3}R4}R5}]!”.
The gray vertices have no life left, so they won’t be displayed in the
representation. The green vertices have 3 lives left, they’ll be
displayed as “0”. The yellow vertices have two lives left, they’ll be
displayed as “1”. There are two sorts of vertices with 1 life left (the
red ones), those that are in two regions (upper-case letters), and
those that are in only one region (lower-case letters).
To write the representation of a region, we enumerate the boundaries.
The end-of boundary character is “.”, and we must pay attention to
orientation : in a given region, we turn counterclockwise around the
outer boundary, and clockwise around the others. So, the representation
will be : “1aa.AB.}AB.}]0.aaABC.}0.1ab1bcDca.ACB.}D.}]!”
It is impossible to play in the region “D.}”, so we delete this region,
and then we replace the letter “D” - that appears only once in the
representation - with the generic number “2”. When a lower case vertex
occurs twice in a row, as in “1aa”, we also replace these two letters
with “2”. The representation we give to the program is :
“12.AB.}AB.}]0.2ABC.}0.1ab1bc2ca.ACB.}]!”.
When inside a region, there is 3 lives or less, it is useless to separate boundaries; so, we delete any "." except the last in the representation. Instead of "2.AB.}AB.]!", the representation of the above position is "2AB.}AB.}]!".
Computation
- Start computation : click on the "Compute" button of the
"Computation" tab.
- Stop computation : you can stop an incomplete computation
at any time, by just clicking on the "Stop" button.
The point reached by computation is regularly refreshed in the
interface, as a vertical list of levels. What we call a “level” is just
the list of children of a given position. When you try to compute the
state of a position (win/loss or nimber), you basically need to compute
the state of its children, and computing is recursive on the
“children”. At a given time, computation can be represented as the list
of each child currently computed in a given level, and that’s exactly
what we display in the interface.
Zapping
First of all we need to understand the underlying game theory. To
compute the win/loss of a position, we need to find one losing child
(so the position is winning; only one losing child is needed), or to
prove that all children are winning (so the position is losing).
As only one losing child is needed to show that a position is winning,
there are several ways to complete a computation. Some of them are much
easier than others, so by choosing to study the right children, you can
make the computation much faster (for instance, it’s easy to be 50
times faster on the n=12 computation !).
Here are the features of the program that help you to choose the
right children :
- Choose a child : you can change the current computed child of any given
level just by clicking on a cell in this level. Click on the first
three cells (”Index”, “Alive”, “Lives”) to reach the next child, and
on the fourth cell (”Nimber”) to reach the previous one.
- Display all children : click on the “Position” cell to display a list
of all children in a given level. Then you just need to click on the
desired child in the list to reach it.
Notice that positions are displayed on the right side of the interface,
so you can choose the positions that seem to be easier to compute (like
those which tend to separate into lands).
We also use a system of colors to guide user choices in the interface.
Green color means that a given level has no more than 4 remaining
children in an unknown state, and red color means there is only one
left. When you see a green or red level, it indicates that the position
on the above level is probably a losing one.
The ideal situation is a succession of the following kind : {green or
red}/any color/{green or red}/any color... Please notice that this
“zapping” game has been found very addictive by its programmers and
they cannot be held responsible for any damage to your social life.
Databases
During a computation, the program stores in a database (the “Main base”) the positions whose nimber is known (ie losing position+nimber). The number of stored positions is indicated on the top left of the interface. Keep an eye on this number, it will help you to control your RAM usage (100,000 positions need approximately 10MB).
You can stop computation, save your database, shut down the
program and then later reload the database to resume the computation. When you do so, be careful to choose the same parameters in the parameters tab.
You also can load several databases to merge them and the program will check that
the results are consistent (an error message is displayed if any position
has a different nimber in two databases).
The “Main base” is not the only database in this program, the other
databases are described below. The default extension for these
databases is “.spr”.
Check computation
Once a computation succeeds, you may want to check the result. By
clicking on the “check” button, the program checks that the database
allows you to compute the position indicated in the “parameters” tab.
An error message is displayed if needed.
The algorithm tries to use the minimal amount of positions to check
this result, storing these positions in the check database. So, using
“check computation”, you can reduce the number of positions. This is
useful to save memory, and also if you want to do hand-checked proofs
for little positions.
You can also save the check database with the appropriate button.
Graph generation
If you tick in the box in the “parameters” tab, a file will be
generated during the check computation. This file will allow you to
either draw a graph of the computation using the program “Graphviz”, or
have a hand-checkable proof, if you read the file with a text editor.
After a check computation, click on the “Save check graph” button, and
save the “.dot” file. Then, if Graphviz is installed on your system,
the command “dot -T png -o example.png example.dot” will generate the
graph. Make sure the graph is readable only if the position isn’t too
complicated (n<6). A node in the graph represents a couple
(position;nimber). On the right of the graph, the number of lives of
the positions of this level is indicated.
Options in the "parameters" tab :
- if you use colors, losing couples will be in red, winning
couples in blue, and couples with several lands will be in yellow.
- detail level : a couple is represented by : a dot (level
1), a number (level 2), the full text describing the couple (level 3).
- you can choose to print only the positions with more than a
certain number of lives. This is useful for complicated positions
(n>5), to show the beginning of the computation.
The graph above shows the beginning of a computation for
n=11. On the right, you can see that only positions from
24 to 33 lives are represented. In this example, we decided to
represent a couple by a number (detail level 2), as it would be
unreadable if we drew all the positions. But if we read the file “.dot”
generated by the program with a text editor, we will see the couples
represented by those numbers.
Here’s another example, with detail level 3. It’s a complete
calculation, for the 3-spot game, showing that the first player has a
winning strategy. On those two graphs, it appears that for a losing
couple (a red one), ie a position whose nimber is known, we must check
that every child is winning, so it is linked to many couples below. On
the contrary, to show that a couple is a winning one (in blue), ie a
position whose number is unknown, we only need to find one losing
child. A yellow couple is a position with several lands, it can either
be winning or losing. To find it, we must check every land composing
this position, further down in the graph.

For a given winning couple, if we know that the nimber is neither a nor
b, then it will be linked to a losing position with nimber a and
another losing position with nimber b. So it sometimes happens that a
winning couple is linked to several children, just like in the graph
below, where the couple 18 (2AB.}AB.}]! not 0 1) is linked to 22
(22.}]! 1) and to 16 (! 0, void position).
Complete check computation
If you click on the "Complete check" button, the program will check the
nimber of any position in the main database, warning you if needed.
Children computation
In the "Children" tab, you can compute the children of a given position.
Make sure you use a correct syntax. If the nimber of the child is known
in the main database, it is printed at the end of the line.
This tab can be used to play Sprouts by correspondence : suppose you
play a 12-spot game. First of all, you compute the win/loss of the
12-spot game with the program, or you load a database that allows you to
solve it. The starting position is a loss, which means you should let
the other player begin. Let’s suppose he does, and that he plays
0.0.0.0.0.0.0.0.AB.}0.0.0.AB.}]!. Then, using the children tab, you
find that the nimber is 0 for 0.0.0.0.A.}0.0.0.0.A.}]0.0.0.}]!, ie it’s
a loss. So you play this. Then, if your opponent plays
0.0.0.0.A.}0.0.0.0.A.}]0.0.AB.}AB.}]!, you can play
0.0.0.0.A.}0.0.0.0.A.}]0.1a2a.}]! because its nimber is 0, etc...
Analysis
You can filter the positions in the main database, keeping only those
that verify some of these parameters :
- Number of lives (you can choose a minimal or a maximal
number of lives).
- Nimber (you can choose a minimal or a maximal nimber).