<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.4//EN" "http://www.docbook.org/xml/4.4/docbookx.dtd">
<article lang="en">
  <articleinfo>
    <title><application moreinfo="none">GNU Backgammon</application> Manual
      V0.16</title>
    <titleabbrev role="texinfo-file">gnubg</titleabbrev>
    <abstract role="texinfo-node">
      <para>The incomplete GNU Backgammon manual</para>
    </abstract>
    <subjectset scheme="texinfo-directory">
      <subject><subjectterm>Games</subjectterm></subject>
    </subjectset>
    <copyright>
      <year>1999</year>
      <year>2000</year>
      <year>2001</year>
      <year>2002</year>
      <year>2003</year>
      <holder>Achim Mueller, Gary Wong</holder>
    </copyright>
    <copyright>
      <year>2007</year>
      <holder>Christian Anthon</holder>
    </copyright>
    <publisher>
      <publishername> GNU Project </publishername>
    </publisher>
    <authorgroup>
      <author>
        <firstname>Christian</firstname>
        <surname>Anthon</surname>
        <affiliation>
          <orgname>GNU Backgammon Project</orgname>
          <address format="linespecific">
            <email>congoneser@gmail.com</email>
          </address>
        </affiliation>
      </author>
    </authorgroup>
    <revhistory>
      <revision>
        <revnumber>GNU Backgammon Manual (docbook version)</revnumber>
        <date>February 2007</date>
        <revdescription>
          <para role="publisher">GNU Backgammon Project</para>
        </revdescription>
      </revision>
      <revision>
        <revnumber>GNU Backgammon Manual (wiki version)</revnumber>
        <date>January 2007</date>
        <revdescription>
          <para role="publisher">GNU Backgammon Project</para>
        </revdescription>
      </revision>
      <revision>
        <revnumber>GNU Backgammon Manual (texinfo version)</revnumber>
        <date>November 2003</date>
        <revdescription>
          <para role="publisher">GNU Backgammon Project</para>
        </revdescription>
      </revision>
    </revhistory>
    <releaseinfo>This manual describes version 0.16 of GNU Backgammon. </releaseinfo>
    <legalnotice>
      <title>Feedback</title>
      <para>To report a bug or make a suggestion regarding the <application moreinfo="none">GNU Backgammon</application> application or this
        manual, send your suggestions to <email>bug-gnubg@gnu.org</email> or
        make a <ulink url="https://savannah.gnu.org/bugs/?group=gnubg">bug
          report</ulink>.</para>
      <para> Permission is granted to copy, distribute and/or modify this
        document under the terms of the GNU Free Documentation License, Version
        1.2 or any later version published by the Free Software Foundation; with
        no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A
        copy of the license is included in <xref linkend="legal"/>. </para>
    </legalnotice>
  </articleinfo>
  <sect1 id="gnubg-intro">
          <sect1info>
    <abstract role="texinfo-node">
      <para>Introduction to GNU Backgammon</para>
    </abstract>
    </sect1info>
    <title>Introduction</title>
    <para>This manual describes how to use <application moreinfo="none">GNU
        Backgammon</application> to play and analyze backgammon games and
      matches. It corresponds to version 0.16-devel (updated in February, 2007).</para>
    <para><application moreinfo="none">GNU Backgammon</application> (gnubg)
      plays and analyzes backgammon games and matches. It is able to play and
      analyze both money games and tournament matches, evaluate and roll out
      positions, and more. Driven by a command-line interface, it displays an
      ASCII rendering of a board on text-only terminals, but also allows the
      user to play games and manipulate positions with a graphical GTK+
      interface. <application moreinfo="none">GNU Backgammon</application> is
      extensible on platforms which support Python. </para>
    <screenshot>
      <mediaobject>
        <imageobject>
          <imagedata fileref="images/gtkinterface.png"/>
        </imageobject>
      </mediaobject>
    </screenshot>
    <para><application moreinfo="none">GNU Backgammon</application> is a world
      class opponent and rates at around 2000 on FIBS, the First Internet
      Backgammon Server – at its best, it is in the top 5 of over 6000 rated
      players there). <application moreinfo="none">GNU Backgammon</application>
      can be played on numerous other on-line backgammon servers.</para>
    <para>The following features can be found in the current release of
        <application>GNU Backgammon</application>.</para>
    <itemizedlist>
      <listitem>
        <para>A command line interface (with full command editing features if
          GNU readline is available) that lets you play matches and sessions
          against GNU Backgammon with a rough ASCII representation of the board
          on text terminals.</para>
      </listitem>
      <listitem>
        <para>Support for a GTK+ interface with a graphical board window. Both
          2D and 3D graphics are available. </para>
      </listitem>
      <listitem>
        <para>Tournament match and money session cube handling and cubeful play.
          All governed by an underlying cubeless money game based
        neuralnet.</para>
      </listitem>
      <listitem>
        <para>Support for both 1-sided and 2-sided bearoff databases: 1-sided
          bearoff database for 15 checkers on the first 6 points and optional
          2-sided database kept in memory. Optional larger 1-sided and 2-sided
          databases stored on disk. </para>
      </listitem>
      <listitem>
        <para>Automated rollouts of positions, with lookahead and race variance
          reduction where appropriate. Rollouts may be extended. </para>
      </listitem>
      <listitem>
        <para>Automatic and manual annotation (analysis and commentary) of games
          and matches.</para>
      </listitem>
      <listitem>
        <para>Record keeping of statistics of players in games and matches (both
          native inside <application moreinfo="none">GNU
          Backgammon</application> and externally using relational databases and
          Python).</para>
      </listitem>
      <listitem>
        <para>Loading and saving analyzed games and matches as .sgf files (Smart
          Game Format).</para>
      </listitem>
      <listitem>
        <para>Exporting positions, games and matches to: (.eps) Encapsulated
          Postscript, (.gam) Jellyfish Game, (.html) HTML, (.mat) Jellyfish
          Match, (.pdf) PDF, (.png) Portable Network Graphics, (.pos) Jellyfish
          Position, (.ps) PostScript, (.sgf) Gnu Backgammon File, (.tex) LaTeX,
          (.txt) Plain Text, (.txt) Snowie Text</para>
      </listitem>
      <listitem>
        <para>Import of matches and positions from a number of file formats:
          (.bkg) Hans Berliner's BKG Format, (.gam) GammonEmpire Game, (.gam)
          PartyGammon Game, (.mat) Jellyfish Match, (.pos) Jellyfish Position,
          (.sgf) Gnu Backgammon File, (.sgg) GamesGrid Save Game, (.tmg)
          TrueMoneyGames, (.txt) Snowie Text</para>
      </listitem>
      <listitem>
        <para>Python Scripting ability. </para>
      </listitem>
      <listitem>
        <para>Native language support; 10 languages complete or in progress:
          (cs_CZ, da_DK, en_GB; en_US, fr_FR, de_DE, is_IS, it_IT, ja_JP, and
          tr_TR) </para>
      </listitem>
    </itemizedlist>
    <note>
      <para>Some language translations are not completed yet.</para>
    </note>
    <sect2 id="gnubg-intro_gpl">
      <title>GPL copying/warranty info</title>
      <para><application moreinfo="none">GNU Backgammon</application> is
        developed under the GNU General Public License (GPL) and it's part of
        the GNU project. If you want to know more about GPL and the Free
        Software Foundation you can visit the <ulink url="http://www.fsf.org/">FSF website</ulink>.</para>
    </sect2>
  </sect1>
  <sect1 id="gnubg-rules">
          <sect1info>
    <abstract role="texinfo-node">
      <para>Backgammon rules by Tom Keith</para>
    </abstract>
    </sect1info>
    <title>Rules of the game</title>
    <para>This section describes how to play a game, a match or a session of
      money games against <application moreinfo="none">GNU
      Backgammon</application>, or a human opponent. Authored by <ulink url="http://www.bkgm.com/rules.html">Tom Keith</ulink>. Skilled
      backgammon players may skip ahead to next section. </para>
    <sect2 id="gnubg-rules_setup">
      <title>Setup</title>
      <para>Backgammon is a game for two players, played on a board consisting
        of twenty-four narrow triangles called points. The triangles alternate
        in color and are grouped into four quadrants of six triangles each. The
        quadrants are referred to as a player's home board and outer board, and
        the opponent's home board and outer board. The home and the outer boards
        are separated from each other by a ridge down the center of the board
        called the bar.</para>
      <figure float="0" id="gnubg-fig_init">
        <title>A board with the checkers in their initial position.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/rulfig1.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>An alternate arrangement is the reverse of the one shown here, with
        the home board on the left and the outer board on the right.</para>
      <para>The points are numbered for either player starting in that player's
        home board. The outermost point is the twenty-four point, which is also
        the opponent's one point. Each player has fifteen checkers of his own
        color. The initial arrangement of checkers is: two on each player's
        twenty-four point, five on each player's thirteen point, three on each
        player's eight point, and five on each player's six point.</para>
      <para>Both players have their own pair of dice and a dice cup used for
        shaking. A double cube, with the numerals 2, 4, 8, 16, 32, and 64 on its
        faces, is used to keep track of the current stake of the game.</para>
    </sect2>
    <sect2 id="gnubg-rules_object">
      <title>Object of the Game</title>
      <para>The object of the game is for a player to move all of his checkers
        into his own home board and then bear them off. The first player to bear
        off all of his checkers wins the game.</para>
      <figure float="0" id="gnubg-fig_direction">
        <title>Direction of movement of White's checkers. Red's checkers move in
          the opposite direction.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/rulfig2.png"/>
          </imageobject>
        </mediaobject>
      </figure>
    </sect2>
    <sect2 id="gnubg-rules_movement">
      <title>Movement of the Checkers</title>
      <para>To start the game, each player throws a single die. This determines
        both the player to go first and the numbers to be played. If equal
        numbers come up, then both players roll again until they roll different
        numbers. The player throwing the higher number now moves his checkers
        according to the numbers showing on both dice. After the first roll, the
        players throw two dice and alternate turns.</para>
      <para>The roll of the dice indicates how many points, or pips, the player
        is to move his checkers. The checkers are always moved forward, to a
        lower-numbered point. The following rules apply:</para>
      <orderedlist continuation="restarts" inheritnum="ignore">
        <listitem>
          <para>A checker may be moved only to an open point, one that is not
            occupied by two or more opposing checkers. </para>
        </listitem>
        <listitem>
          <para>The numbers on the two dice constitute separate moves. For
            example, if a player rolls 5 and 3, he may move one checker five
            spaces to an open point and another checker three spaces to an open
            point, or he may move the one checker a total of eight spaces to an
            open point, but only if the intermediate point (either three or five
            spaces from the starting point) is also open.</para>
          <figure float="0" id="gnubg-fig_opening">
            <title>White opens the game with 53.</title>
            <mediaobject>
              <imageobject>
                <imagedata fileref="images/rulfig3.png"/>
              </imageobject>
            </mediaobject>
          </figure>
        </listitem>
        <listitem>
          <para>A player who rolls doubles plays the numbers shown on the dice
            twice. A roll of 6 and 6 means that the player has four sixes to
            use, and he may move any combination of checkers he feels
            appropriate to complete this requirement. </para>
        </listitem>
        <listitem>
          <para>A player must use both numbers of a roll if this is legally
            possible (or all four numbers of a double). When only one number can
            be played, the player must play that number. Or if either number can
            be played but not both, the player must play the larger one. When
            neither number can be used, the player loses his turn. In the case
            of doubles, when all four numbers cannot be played, the player must
            play as many numbers as he can. </para>
        </listitem>
      </orderedlist>
    </sect2>
    <sect2 id="gnubg-rules_hitting">
      <title>Hitting and Entering</title>
      <para>A point occupied by a single checker of either color is called a
        blot. If an opposing checker lands on a blot, the blot is hit and placed
        on the bar.</para>
      <para>Any time a player has one or more checkers on the bar, his first
        obligation is to enter those checker(s) into the opposing home board. A
        checker is entered by moving it to an open point corresponding to one of
        the numbers on the rolled dice.</para>
      <para>For example, if a player rolls 4 and 6, he may enter a checker onto
        either the opponent's four point or six point, so long as the
        prospective point is not occupied by two or more of the opponent's
        checkers.</para>
      <figure float="0" id="gnubg-fig_bar">
        <title>White rolls 64 with a checker on the bar.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/rulfig4.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para> If White rolls [64] with a checker on the bar, he must enter the
        checker onto Red's four point since Red's six point is not open. If
        neither of the points is open, the player loses his turn. If a player is
        able to enter some but not all of his checkers, he must enter as many as
        he can and then forfeit the remainder of his turn.</para>
      <para>After the last of a player's checkers has been entered, any unused
        numbers on the dice must be played, by moving either the checker that
        was entered or a different checker.</para>
    </sect2>
    <sect2 id="gnubg-rules_bearingoff">
      <title>Bearing Off</title>
      <para>Once a player has moved all of his fifteen checkers into his home
        board, he may commence bearing off. A player bears off a checker by
        rolling a number that corresponds to the point on which the checker
        resides, and then removing that checker from the board. Thus, rolling a
        6 permits the player to remove a checker from the six point.</para>
      <para>If there is no checker on the point indicated by the roll, the
        player must make a legal move using a checker on a higher-numbered
        point. If there are no checkers on higher-numbered points, the player is
        permitted (and required) to remove a checker from the highest point on
        which one of his checkers resides. A player is under no obligation to
        bear off if he can make an otherwise legal move.</para>
      <figure float="0" id="gnubg-fig_bearoff">
        <title>White rolls 64 and bears off two checkers.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/rulfig5.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>A player must have all of his active checkers in his home board in
        order to bear off. If a checker is hit during the bear-off process, the
        player must bring that checker back to his home board before continuing
        to bear off. The first player to bear off all fifteen checkers wins the
        game.</para>
    </sect2>
    <sect2 id="gnubg-rules_doubling">
      <title>Doubling</title>
      <para>Backgammon is played for an agreed stake per point. Each game starts
        at one point. During the course of the game, a player who feels he has a
        sufficient advantage may propose doubling the stakes. He may do this
        only at the start of his own turn and before he has rolled the dice.</para>
      <para>A player who is offered a double may refuse, in which case he
        concedes the game and pays one point. Otherwise, he must accept the
        double and play on for the new higher stakes. A player who accepts a
        double becomes the owner of the cube and only he may make the next
        double.</para>
      <para>Subsequent doubles in the same game are called redoubles. If a
        player refuses a redouble, he must pay the number of points that were at
        stake prior to the redouble. Otherwise, he becomes the new owner of the
        cube and the game continues at twice the previous stakes. There is no
        limit to the number of redoubles in a game.</para>
    </sect2>
    <sect2 id="gnubg-rules_gammons">
      <title>Gammons and Backgammons</title>
      <para>At the end of the game, if the losing player has borne off at least
        one checker, he loses only the value showing on the double cube (one
        point, if there have been no doubles). However, if the loser has
          <emphasis>not</emphasis> borne off any of his checkers, he is gammoned
        and loses <emphasis>twice</emphasis> the value of the double cube. Or,
        worse, if the loser has not borne off any of his checkers and still has
        a checker on the bar or in the winner's home board, he is backgammoned
        and loses <emphasis>three times</emphasis> the value of the double
      cube.</para>
    </sect2>
    <sect2 id="gnubg-rules_optional">
      <title>Optional Rules</title>
      <para>The following optional rules are in widespread use.</para>
      <orderedlist continuation="restarts" inheritnum="ignore">
        <listitem>
          <para>Automatic doubles. If identical numbers are thrown on the first
            roll, the stakes are doubled. The double cube is turned to 2 and
            remains in the middle. Players usually agree to limit the number of
            automatic doubles to one per game. </para>
        </listitem>
        <listitem>
          <para>Beavers. When a player is doubled, he may immediately redouble
            (beaver) while retaining possession of the cube. The original
            doubler has the option of accepting or refusing as with a normal
            double. </para>
        </listitem>
        <listitem>
          <para>The Jacoby Rule. Gammons and backgammons count only as a single
            game if neither player has offered a double during the course of the
            game. This rule speeds up play by eliminating situations where a
            player avoids doubling so he can play on for a gammon. </para>
        </listitem>
      </orderedlist>
    </sect2>
    <sect2 id="gnubg-rules_match">
      <title>Rules for Match Play</title>
      <para>When backgammon tournaments are held to determine an overall winner,
        the usual style of competition is match play. Competitors are paired
        off, and each pair plays a series of games to decide which player
        progresses to the next round of the tournament. This series of games is
        called a match.</para>
      <para>Matches are played to a specified number of points. The first player
        to accumulate the required points wins the match. Points are awarded in
        the usual manner: one for a single game, two for a gammon, and three for
        a backgammon. The double cube is used, so the winner receives the value
        of the game multiplied by the final value of the double cube.</para>
      <para>Matches are normally played using the Crawford rule. The Crawford
        rule states that if one player reaches a score one point short of the
        match, neither player may offer a double in the immediately following
        game. This one game with no doubling is called the Crawford game. If the
        Crawford game is won by the trailing player then the double cube becomes
        available in all subsequent games (and it's most often in the best
        interests of the trailing player to double immediately in these games).</para>
      <informaltable frame="all">
        <tgroup cols="3">
          <tbody>
            <row>
                    <entry>Match to 5</entry>
                    <entry>White</entry>
                    <entry>Black</entry>
                    </row> <row>
              <entry>Game 1: White wins 2 points</entry>
              <entry>2</entry>
<entry>0</entry>
              <entry>Doubling Allowed</entry>
</row>
            <row>
              <entry>Game 2: Black wins 1 point</entry>
              <entry>2</entry>
<entry>1</entry>
              <entry>Doubling Allowed</entry>
</row>
            <row>
              <entry>Game 3: White wins 2 points</entry>
              <entry>4</entry>
              <entry>1</entry>
              <entry>Doubling Allowed</entry>
</row>
            <row>
              <entry>Game 4: Black wins 1 point</entry>
              <entry>4</entry>
              <entry>2</entry>
              <entry>Crawford Game</entry>
</row>
            <row>
              <entry>Game 5: Black wins 2 points</entry>
              <entry>4</entry>
              <entry>4</entry>
              <entry>Doubling Allowed</entry>
</row>
            <row>
              <entry>Game 6: White wins 2 points</entry>
              <entry>6</entry>
              <entry>4</entry>
              <entry>Doubling Allowed</entry>
</row>
          </tbody>
        </tgroup>
      </informaltable>
      <para>In this example, White and Black are playing a 5-point match. After
        three games White has 4 points, which is just one point short of what he
        needs. That triggers the Crawford rule which says there can be no
        doubling in next game, Game 4.</para>
      <para>There is no bonus for winning more than the required number of
        points in match play. The sole goal is to win the match, and the size of
        the victory doesn't matter.</para>
      <para>Automatic doubles, beavers, and the Jacoby rule are not used in
        match play.</para>
    </sect2>
  </sect1>
  <sect1 id="gnubg-starting">
          <sect1info>
    <abstract role="texinfo-node">
      <para>Starting GNU Backgammon. Command line options.</para>
    </abstract>
    </sect1info>
    <title>Starting GNU Backgammon</title>
    <sect2 id="gnubg-starting_unix">
      <title>Linux and Unix</title>
      <para>If <application moreinfo="none">GNU Backgammon</application> is
        properly installed on your system, you can start it by simply typing
        gnubg at the command prompt. If you want to start the GNU Backgammon
        command line interface, you can type gnubg --tty or gnubg -t. With this
        option, <application moreinfo="none">GNU Backgammon</application> starts
        without the graphic user interface. There is also other options which
        can be added at the start-up.</para>
    </sect2>
    <sect2 id="gnubg-starting_ms">
      <title>Microsoft Windows</title>
      <para>The builds of <application moreinfo="none">GNU
        Backgammon</application> which may be downloaded from the <ulink url="http://www.gnubg.org">main <application moreinfo="none">GNU
            Backgammon</application> page</ulink> comes with an installation
        system. The installation system will create a launch menu item in your
        start menu. Usually the menu item can be found by choosing <menuchoice moreinfo="none"><guimenu moreinfo="none">Start</guimenu><guimenuitem moreinfo="none">Programs</guimenuitem><guimenuitem moreinfo="none">GNU Backgammon</guimenuitem><guimenuitem moreinfo="none">GNU Backgammon for Windows.</guimenuitem></menuchoice>.</para>
      <para><application moreinfo="none">GNU Backgammon</application> also has a
        command line interface. This is supplied as a separate executable file
        on Microsoft Windows. You can start this version of <application moreinfo="none">GNU Backgammon</application> by choosing <menuchoice moreinfo="none"><guimenu moreinfo="none">Start</guimenu><guimenuitem moreinfo="none">Programs</guimenuitem><guimenuitem moreinfo="none">GNU Backgammon</guimenuitem><guimenuitem moreinfo="none">GNU Backgammon Command Line
          Interface.</guimenuitem></menuchoice>
      </para>
    </sect2>
    <sect2 id="gnubg-starting_mac">
      <title>Mac OSX</title>
      <para>Once you have installed both an X11R6 server and <application moreinfo="none">GNU Backgammon</application> for MacOS X, you can run
          <application moreinfo="none">GNU Backgammon</application> for MacOS X
        by:</para>
      <orderedlist continuation="restarts" inheritnum="ignore">
        <listitem>
          <para>Start your X11R6 server; </para>
        </listitem>
        <listitem>
          <para>Once your X11R6 server is running, in one of its Terminal
            windows (by default, Apple's X11 opens one such window at start-up,
            and XDarwin opens three), do the following: </para>
          <orderedlist continuation="restarts" inheritnum="ignore">
            <listitem>
              <para>If you have installed <application moreinfo="none">GNU
                  Backgammon</application> in your private Applications folder,
                type <command> cd Applications/gnubg</command> to get into
                  <application moreinfo="none">GNU Backgammon</application> for
                MacOS X's folder, and then type <command>./gnubg</command> to
                run it;</para>
            </listitem>
            <listitem>
              <para>If you have installed <application moreinfo="none">GNU
                  Backgammon</application> in the global, top-level Applications
                folder, type <command>cd /Applications/gnubg</command> to get
                into <application moreinfo="none">GNU Backgammon</application>
                for MacOS X's folder, and type <command>./gnubg</command> to run
                it; </para>
            </listitem>
          </orderedlist>
        </listitem>
      </orderedlist>
    </sect2>
    <sect2 id="gnubg-starting_options">
      <title>Command line options</title>
      <para> The following options control the startup of <application moreinfo="none">GNU Backgammon</application>. Most options are
        available in all versions of <application moreinfo="none">GNU
        Backgammon</application>, but notably, the -w and -t options don't work
        under MS windows where separate command line and GUI applications exist
        instead.</para>
      <example id="gnubg-options">
        <title>GNU Backgammon startup options</title>
        <programlisting format="linespecific">
            Usage:
            gnubg [OPTION...] [file.sgf]

            Help Options:
            -?, --help                   Show help options
            --help-all                   Show all help options
            --help-gtk                   Show GTK+ Options

            GTK+ Options
            --class=CLASS                Program class as used by the window manager
            --name=NAME                  Program name as used by the window manager
            --screen=SCREEN              X screen to use
            --sync                       Make X calls synchronous
            --gtk-module=MODULES         Load additional GTK+ modules
            --g-fatal-warnings           Make all warnings fatal

            Application Options:
            -b, --no-bearoff             Do not use bearoff database
            -c, --commands=FILE          Evaluate commands in FILE and exit
            -d, --datadir=DIR            Read database and weight files from DIR
            -l, --lang=LANG              Set language to LANG
            -n, --new-weights=N          Create new neural net (of size N)
            -p, --python=FILE            Evaluate Python code in FILE and exit
            -q, --quiet                  Disable sound effects
            -r, --no-rc                  Do not read .gnubgrc and .gnubgautorc commands
            -S, --no-splash              Don't show gtk splash screen
            -t, --tty                    Start on tty instead of using window system
            -v, --version                Show version information and exit
            -w, --window-system-only     Ignore tty input when using window system
            --display=DISPLAY            X display to use
          </programlisting>
      </example>
    </sect2>
  </sect1>
  <sect1 id="gnubg-playing">
    <title>Playing a game</title>
    <sect2 id="gnubg-playing_new">
      <title>Starting a new match</title>
      <para>To start a new game, match or session choose <menuchoice moreinfo="none"><guimenu moreinfo="none">File</guimenu><guimenuitem moreinfo="none">New</guimenuitem></menuchoice>, or use the <guibutton>New</guibutton> button in the
        toolbar. This will open a dialog box, where you can select the main
        options for the new backgammon game you are about to begin. </para>
      <figure float="0" id="gnubg-fig_newdialog">
        <title>The dialog for starting a new match.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/newbox.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>The shortcut buttons are the quickest way to start the game or
        match. If you click on the button with the $ sign, you will start a new
        money game session immediately. If you click on a numbered button, you
        will start a new match of the specified length.</para>
      <para>The dialog allows a fine tuning of the startup options:</para>
      <orderedlist continuation="restarts" inheritnum="ignore">
        <listitem>
          <para>Use the radio buttons to choose whether you want to start a
            match, game or session. If you wish to start a new match, you should
            select the match length by typing into the Match length field.
          </para>
        </listitem>
        <listitem>
          <para>You may play against both the program itself or against a
            friend. If you want to start a match or game against a friend,
            select the Human vs. Human option.</para>
        </listitem>
        <listitem>
          <para>Normally the dice are generated by a random number generator,
            but you may use manual dice if you check this option. Then
              <application> GNU Backgammon</application> will prompt for the
            dice roll before each roll.</para>
        </listitem>
        <listitem>
          <para><application>GNU Backgammon</application> comes with a tutor
            mode. If this mode is active, GNU Backgammon analyzes each move you
            do, and warn you each time you make a mistake. More about tutor mode
            later.</para>
        </listitem>
        <listitem>
          <para>By clicking on the Modify player settings... button, you will
            see the whole player setting dialog. Here you define the playing
            strength of <application>GNU Backgammon</application>. This dialog
            will be explained later.</para>
        </listitem>
      </orderedlist>
    </sect2>
    <sect2 id="gnubg-playing_roll">
      <title>Rolling the dice</title>
      <para>The simplest way to roll the dice is to click in the right board
        area between the board points. You can also roll the dice from the menu <menuchoice><guimenu>Game</guimenu><guimenuitem>Roll</guimenuitem></menuchoice> or with the keyboard shortcut <keycombo><keycap>Ctrl</keycap><keycap>R</keycap></keycombo>.</para>
      <figure float="0" id="gnubg-fig_roll">
        <title>Click in the red rectangle to roll the dice.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/rolldice.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>When you have moved your checkers to make the desired move, you
        complete your turn by clicking on the dice.</para>
    </sect2>
    <sect2 id="gnubg-playing_move">
      <title>Moving the checkers</title>
      <sect3 id="gnubg-playing_move_drag">
        <title>Moving by drag and drop</title>
        <para>One way to move the checkers is to click on a checker you want to
          move and then drag it, while holding the mouse button down, to the
          desired designation point. If you have the option Show target help
          when dragging checkers enabled, you will see the a green guiding at
          any legal target point for the checker you are dragging. You can find
          this option by choosing <menuchoice><guimenu>Settings</guimenu><guimenuitem>Options...</guimenuitem><guimenuitem>Display</guimenuitem></menuchoice>
        </para>
      </sect3>
      <sect3 id="gnubg-playing_move_click">
        <title>Moving checkers by clicking</title>
        <para>Move the mouse cursor over the checker you want to move. If you
          now click the <emphasis>left</emphasis> mouse button, the checker will
          move the pips of the <emphasis>left</emphasis> die. If you have
          already moved one checker, clicking on a new checker will move it
          according to the pips of the remaining die. If you click with the
            <emphasis>right</emphasis> mouse button on a checker, the checker
          will move according to the <emphasis>right</emphasis> die.</para>
        <para>Using this method for moving the checkers can be really effective.
          Some users prefer showing the higher die to the left. You can make
            <application>GNU Backgammon</application> show the highest die to
          the left if you choose <menuchoice><guimenu> Settings </guimenu><guimenuitem> Options... </guimenuitem><guimenuitem> Dice </guimenuitem></menuchoice> and check the check box labeled Show higher die on
        left.</para>
      </sect3>
      <sect3 id="gnubg-playing_move_undo">
        <title>Undo a move</title>
        <para>Before you complete your move by clicking the dice, it's possible
          to undo your moves and return to the position before any checkers have
          been moved. You can either click the Undo button in the toolbar, or
          you can choose <menuchoice><guimenu> Edit </guimenu><guimenuitem> Undo </guimenuitem></menuchoice> from the menu or the keyboard shortcut <keycombo><keycap>Ctrl</keycap><keycap>Z</keycap></keycombo>.</para>
      </sect3>
      <sect3 id="gnubg-playing_move_shortcut">
        <title>Some shortcuts</title>
        <para>There are some shortcuts for moving the checkers. You can
            <emphasis>make a new point</emphasis> by right clicking on the empty
          point that you want to make. As an example, if you roll 31 as the
          opening roll, and you want to play 8/5 6/5, you simply place the mouse
          cursor on the 5-point and right click. Making points this way also
          works if you hit a checker, and with doubles.</para>
        <para>Another shortcut can be used in the bearoff phase of the game. By
          clicking in the bearoff tray, <emphasis>two checkers will be born
          off</emphasis> if such a move is legal.</para>
        <para><application>GNU Backgammon</application> can auto play forced
          moves for you. This feature can be enabled by choosing <menuchoice><guimenu> Settings </guimenu><guimenuitem> Options... </guimenuitem><guimenuitem> Game </guimenuitem></menuchoice>, and then check the box Play forced moves
        automatically.</para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-playing_double">
      <title>Using the double cube</title>
      <sect3 id="gnubg-playing_double_offer">
        <title>Offering a double</title>
        <para>You offer a double to your opponent by clicking on the cube. This
          will offer the cube immediately. You can also click <menuchoice><guimenu>Game</guimenu><guimenuitem>Double</guimenuitem></menuchoice> from the menu or the keyboard shortcut <keycombo><keycap>Ctrl</keycap><keycap>D</keycap></keycombo>.</para>
      </sect3>
      <sect3 id="gnubg-playing_double_tp">
        <title>Accepting or declining a cube</title>
        <para>You accept a double made by your opponent by clicking on the
          offered double cube at the board. If you want to decline the double,
          you can right click on the cube.</para>
        <para>There are also three buttons in the toolbar for handling cube
          offers. These buttons are marked Accept, Decline and Beaver. The
          beaver button is only activated in money game sessions where beavers
          are allowed.</para>
        <figure float="0" id="gnubg-fig_double">
          <title>The toolbar double buttons.</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/cubebuttons.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>There are also menu options from the drop down menu for all the
          cube actions. Click <menuchoice><guimenu>Game</guimenu><guimenuitem>Take</guimenuitem></menuchoice> from the menu, to accept an offered double(<keycombo><keycap>Ctrl</keycap><keycap>T</keycap></keycombo>). Click <menuchoice><guimenu>Game</guimenu><guimenuitem>Drop</guimenuitem></menuchoice>, from the menu, to to decline an offered double(<keycombo><keycap>Ctrl</keycap><keycap>P</keycap></keycombo>). Click <menuchoice><guimenu>Game</guimenu><guimenuitem>Beaver</guimenuitem></menuchoice>, from the menu, to beaver an offered double. </para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-playing_resign">
      <title>Resigning</title>
      <sect3 id="gnubg-playing_resign_offer">
        <title>Offering a resignation</title>
        <para>It's also possible to resign during a game. To resign during play
          press the Resign button in the toolbar. This is the button with the
          image of a white flag. When this button is pressed, a dialog box will
          appear where you can select if you want to resign a single game,
          gammon or backgammon. The resignation dialog may also be reached from
          the menu system. Click <menuchoice><guimenu>Game</guimenu><guimenuitem>Resign</guimenuitem></menuchoice> to offer your resignation.</para>
      </sect3>
      <sect3 id="gnubg-playing_resign_accept">
        <title>Accepting or declining a resignation</title>
        <para>When a resignation is offered a white square will appear on the
          board area. The square has a number 1, 2 or 3. A square with a
            <emphasis>1</emphasis>, means that a single game resignation is
          offered, a <emphasis>2</emphasis> that a gammon resignation is
          offered, and a <emphasis>3</emphasis>, means that a backgammon is
          offered. If you're using a 3D board, the resignation will be a white
          flag instead of a square.</para>
        <para>To accept the resignation click on the numbered square. If you
          want to decline the resignation, you right click instead. You can also
          use the same toolbar buttons as for accepting or declining a double.
          There is also a menu option for accepting and declining resignations.
          Click <menuchoice><guimenu>Game</guimenu><guimenuitem>Agree to resignation</guimenuitem></menuchoice> from the menu, to accept an offered resignation. Click <menuchoice><guimenu>Game</guimenu><guimenuitem>Decline resignation</guimenuitem></menuchoice> from the menu, to decline an offered resignation.</para>
      </sect3>
    </sect2>
  </sect1>
  <sect1 id="gnubg-hint">
    <title>Getting hints and Tutor Mode</title>
    <sect2 id="gnubg-hint_manual">
            <title>Getting hints manually</title>
    <sect3 id="gnubg-hint_tutor_checker">
      <title>Getting checker play hints while playing</title>
      <para>If you want to get a hint of the best move or the best cube action
              press the Hint button in the tool bar or the menu option
              <menuchoice><guimenu>Analyze</guimenu><guimenuitem>Hint</guimenuitem></menuchoice>.
              This will open a hint window.</para>
      <figure float="0" id="gnubg-fig_hint">
        <title>The hint window</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/hintwindow.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>This Hint window shows a list of all possible moves for the position
        and dice roll. The different moves are sorted by how <application>GNU
          Backgammon</application> ranks each move; there is one move on each
        line in the list. The rest of the numbers may look a bit complicated and
        cryptic but, once you learn what each number means, it isn't really that
        bad.</para>
      <orderedlist continuation="restarts" inheritnum="ignore">
        <listitem>
          <para><emphasis>Rank</emphasis> is the number that shows
              <application>GNU Backgammon</application>'s rank of the move. All
            moves evaluated at a given ply are ranked above those evaluated at a
            lesser ply. If you use the 0, 1, 2, etc, buttons below the hint list
            to re-evaluate one or more moves, the moves will be moved
            accordingly. Therefore, for accurate results when re-evaluating a
            move that you are interested in, it is usually best to
              <emphasis>re-evaluate all moves above it in the list</emphasis>.
            (And slipping with the mouse and re-evaluating, e.g., a 3-ply move
            at 2-ply may make the move <emphasis>disappear</emphasis> down to
            the bottom of the list!) </para>
        </listitem>
        <listitem>
          <para><emphasis>Type</emphasis> is a description of the evaluation
            that was used to calculate the results. Cubeful means that it is
            taking into account the possibility that someone may double.
            Occasionally you may see several moves with the equity of -1.000,
            (See <emphasis>Equity</emphasis> below), despite significantly
            different winning percentiles. This is because it thinks that if any
            of these moves are played then the opponent will double and you
            should pass. The n-ply is the depth to which <application>GNU
              Backgammon</application> analyzed the move. </para>
        </listitem>
        <listitem>
          <para><emphasis>Win</emphasis> is the fractions of games that
              <application>GNU Backgammon</application> thinks will be won by a
            single game, gammon or backgammon. </para>
        </listitem>
        <listitem>
          <para><emphasis>Wg</emphasis> is the fractions of games that
              <application>GNU Backgammon</application> thinks will be won by a
            gammon or backgammon. </para>
        </listitem>
        <listitem>
          <para><emphasis>Wbg</emphasis> is the fractions of games that
              <application>GNU Backgammon</application> thinks will be won by a
            backgammon. </para>
        </listitem>
        <listitem>
          <para><emphasis>Loose</emphasis> is the fractions of games that
              <application>GNU Backgammon</application> thinks will be lost by a
            single game, gammon or backgammon. (Notice that this number is equal
            to 1 - Win) </para>
        </listitem>
        <listitem>
          <para><emphasis>Lg</emphasis> is the fractions of games that
              <application>GNU Backgammon</application> thinks will be lost by a
            gammon or backgammon. </para>
        </listitem>
        <listitem>
          <para><emphasis>Lbg</emphasis> is the fractions of games that
              <application>GNU Backgammon</application> thinks will be lost by a
            backgammon. </para>
        </listitem>
        <listitem>
          <para><emphasis>Equity</emphasis> is the overall evaluation of the
            position by the program, after considering the different win/loss
            percentiles, the cube position, and the match score. A 1.000 would
            mean that you are expected to win a point, a 0.000 would mean that
            it is roughly equal, and a -1.000 that you are expected to lose a
            point. When the evaluation is cubeful this number is not computable
            by the win/loss brake down of the previous columns. </para>
        </listitem>
        <listitem>
          <para><emphasis>Diff.</emphasis> is the difference in equity,
            perceived in comparison to the top ranked move. </para>
        </listitem>
        <listitem>
          <para><emphasis>Move</emphasis> is the move being evaluated. In the
            case of a red line, it is the move that was played. </para>
        </listitem>
      </orderedlist>
    </sect3>
    <sect3 id="gnubg-hint_manual_cube">
      <title>Getting cube decision hints while playing</title>
      <para>If you're thinking about a cube decision before rolling you can
        press the same Hint button in the toolbar, as you pressed when you
        wanted checker play hint. The hint window will again appear, but this
        time it will look a bit different and it will show a hint of the correct
        cube decision.</para>
      <figure float="0" id="gnubg-fig_cubehint">
        <title>The cube hint window</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/hintcubewindow.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>The first lines is the window dialog shows the evaluation depth, and
        the cubeless equity with the evaluated probabilities. This equity is
        compensated for the match score. The cubeless equity for a money game,
        where the the calculation of equity is not compensated for match score,
        is also reported.</para>
      <para>Next follow three lines with cubeful equities. In figure above, the
        cubeful equity for the player on roll for not doubling at this turn, is
        +0.123. The equity for a double and the opponent passing is (of course)
        +1.000, since the player then will win one point. (The number is
        normalized to cube value of one, so even if it is a redouble to 4 or 8
        or higher, the cubeful equity for double/pass is still +1.000 for the
        doubler.) The third number in figure above is the cubeful equity for the
        player doubling and the opponent accepting the double. The different
        option will be listed in order with the best option highest. The number
        right to the listed equities is the differences from the cube decision
        considered best.</para>
      <para>The last line states the best considered cube action. In the figure
        above, <application>GNU Backgammon</application> considers the best cube
        action to be No double, take. When percentage number right to the proper
        cube action, is a number which indicates the <emphasis>bluff</emphasis>
        potential. It is the necessary percentage chance you think you can bluff
        your opponent into passing the cube to make the double theoretically
        correct. This number is only available when the position is considered
        No double, take or Too good to double, pass.</para>
</sect3>
    <sect3 id="gnubg-hint_button">
      <title>The hint tool buttons</title>
      <para>As you may see in both figures above, there is a set of buttons
        below the move list or cube analysis. Here follows a short description
        of what each of the buttons does:</para>
      <orderedlist continuation="restarts" inheritnum="ignore">
        <listitem>
          <para><emphasis>Eval</emphasis> will evaluate the selected moves, or
            the cube decision with the current evaluation setting. </para>
        </listitem>
        <listitem>
          <para><emphasis>...</emphasis> will open the evaluation setting
            dialog. You can then modify the evaluation setting. More about
            evaluation settings in the next chapter. </para>
        </listitem>
        <listitem>
          <para><emphasis>0 1 2 3 4</emphasis> will evaluate the selected moves
            or cube decision at cubeful 0-ply or cubeful 1-ply or cubeful 2-ply
            and so on. </para>
        </listitem>
        <listitem>
          <para><emphasis>Rollout</emphasis> will start a rollout ((A
              <emphasis>rollout</emphasis> is simply a Monte Carlo simulation of
            a backgammon position. More about rollouts in a later chapter.)) of
            the selected moves or cube decision. </para>
        </listitem>
        <listitem>
          <para><emphasis>...</emphasis> will open the rollout settings dialog.
            This dialog will be further described later in this manual. </para>
        </listitem>
        <listitem>
          <para><emphasis>MWC</emphasis> (Match Winning Chance). If this button
            is pressed the values in the hint window will be shown as the chance
            to win the whole match. If this button is unpressed or there is a
            money game that's played, the values in the hint window is reported
            as Equity. Notice, The equity in a match is actually a recalculation
            from match winning chance to equity. This recalculated number is
            often referred to as EMG, Equivalent to Money Game. The EMG number
            is comparable to the equity in a money game, and are therefore
            labeled 'Equity'. </para>
        </listitem>
        <listitem>
          <para><emphasis>Show</emphasis> will show the board as it would be
            after the selected move is made. The button is only available in the
            checker play hint window. </para>
        </listitem>
        <listitem>
          <para><emphasis>Move</emphasis> will make the move selected in the
            list. It's also possible to make a move directly from the list by
            double clicking on the move. The button is also available only in
            the checker play hint window. </para>
        </listitem>
        <listitem>
          <para><emphasis>Copy</emphasis> will copy the text of all selected
            moves to clipboard. </para>
        </listitem>
        <listitem>
          <para><emphasis>Temp. Map</emphasis> will show Sho Sengoku's
            temperature map. This map is further described later in the
            document. When this window remembers its size and position it will
            really become useful. </para>
        </listitem>
      </orderedlist>
      </sect3>
    </sect2>
    <sect2 id="gnubg-hint_tutor">
      <title>Tutor mode</title>
      <para>One of the greatest tools for learning, is Tutor Mode. Tutor mode
        can be activated by clicking <menuchoice><guimenu>Settings</guimenu><guimenuitem>Options...</guimenuitem></menuchoice> and then click on the Tutor flag. Activate Tutor Mode by
        checking the Tutor mode check box.</para>
      <figure float="0" id="gnubg-fig_tutor">
        <title>The tutor window</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/tutor.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>In Tutor Mode, <application>GNU Backgammon</application> will
        analyze your moves and/or cube decisions and compare them with its
        choices. You set the threshold for its alerts, for example, if you set
        it for bad then it will only warn you when you make a bad mistake. It
        will then allow you to re-examine your choice, go right ahead with it,
        or provide a 'hint' - essentially, showing you its analysis.</para>
      <para>The tutor can give warnings on both cube decisions and checker play.
        If you want the tutor to only warn on cube decisions, you can uncheck
        the box for the Checker play. Likewise, if you want it to only warn on
        checker play decisions, you can uncheck the box for the Cube decisions.</para>
      <figure float="0" id="gnubg-fig_tutorwarn">
        <title>The tutor warning window</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/tutorwarning.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>In the above figure, you can see a warning dialog from the tutor
        mode. If you press the button labeled Play anyway, the move you made
        will be kept and the game will continue. If you press the Rethink
        button, the dialog will close and the checkers that you moved will be
        returned to their original positions. You can then rethink the position
        and try an alternative move. Keep doing this until the Tutor accepts
        your move as being good enough. Alternatively you can press the Hint
        button to show the hint window with its list of possible moves and their
        evaluations. Finally, if you press the End Tutor Mode button, the dialog
        will close and turn Tutor Mode off.</para>
      <para>A similar warning window will also appear for poor cube
      handling.</para>
    </sect2>
  </sect1>
    <sect1 id="gnubg-time">
      <title>Time controls</title>
      <para>The time control feature is not fully implemented with the user
        interface yet. Hopefully this will be improved in the future.</para>
    </sect1>
  <sect1 id="gnubg-edit">
    <title>Setting up a position</title>
    <para>Think about the Friday night chouette where there was this tough
      choice between two move candidates. Which move was the best? Or what about
      that match score cube decision from the weekend tournament. Wouldn't it be
      nice to be able to set up the position in <application>GNU
      Backgammon</application> and ask for it's opinion? This is possible in
        <application>GNU Backgammon</application>, and it's one of the features
      that really can give you the answer to a lot of questions, and in that way
      give you a better understanding of the game.</para>
    <sect2 id="gnubg-edit_entering">
      <title>Entering Edit mode</title>
      <para>To set up a position, you have to be in <emphasis>Edit
        mode</emphasis>. To enter Edit mode you simply click the Edit button in
        the tool bar. There is currently no keyboard shortcut or menu item for
        entering edit mode. The Edit button is a toggle button and you will stay
        in edit mode until you release the button by clicking it again.</para>
      <para>If your Edit button in the toolbar is disabled it is because there
        is no game or match in progress. With the current state of
          <application>GNU Backgammon</application> there must be a game or
        match in progress to be able to enter edit mode. (This may change in the
        future.) If there is no game in progress and you want to set up a
        position, you can simply start a new game or match by clicking New in
        the toolbar.</para>
      <para>When you are in edit mode you will see the the text (Editing) in the
        match information box below the board.</para>
    </sect2>
    <sect2 id="gnubg-edit_edit">
      <title>Editing</title>
      <para>Setting up a position is basically done by editing the current
        position. The editing it self is controlled by clicking different areas
        of the board and may not be obvious at first hand.</para>
    </sect2>
    <sect2 id="gnubg-edit_clear">
      <title>Clearing the board</title>
      <para>In edit mode you can easily clear the board by clicking in one of
        the bearoff trays. It's often easier to start setting up a position with
        a empty board, so this feature is really handy. When you click on one of
        the bearoff tray, all checkers will be moved to the bearoff.</para>
      <figure float="0" id="gnubg-fig_clear">
        <title>Click in the one of the areas marked with a red ellipse to clear
          the board.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/clearboard.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>You can also just as easy generate the initial position by clicking
        the opposite trays when in edit mode. Clicking in one of these trays
        puts all checkers back to the initial position.</para>
      <figure float="0" id="gnubg-fig_initpos">
        <title>Click in the one of the areas marked with a red ellipse to get to
          the initial position.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/initialboard.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>Note that the bearoff trays change side when the board is displayed
        with clockwise movement.</para>
    </sect2>
    <sect2 id="gnubg-edit_quick">
      <title>Quick edit</title>
      <para>The default method of editing a position is called <emphasis>Quick
          edit</emphasis>. It's based on clicking on the point where you want to
        place checkers. The number of checkers placed on the point is depending
        on where you click, for example if you want to place 3 checkers on a
        point, clicking on the location where the third checker would go places
        3 checkers. This method should be familiar to Snowie users.</para>
      <para>Clicking with the left button places checkers for player1, clicking
        with the right button places checkers for player2. If you want to place
        more than 5 checkers, click multiple times on the tip of the point. To
        clear a point, click on the border of the board below or above the point
        - depending on if the point is in the lower or top half of the board.
        The bar works just like normal points - the more you click to the middle
        of the bar, the more checkers will be placed there.</para>
    </sect2>
    <sect2 id="gnubg-edit_drag">
      <title>Editing by drag and drop</title>
      <para>There is also a different way of editing the checker positions. You
        can drag and drop checkers around the board while you're holding down
        the Ctrl key on your keyboard. Press the Ctrl key and hold it down. Then
        left-click the checker you want to drag to another point and drag it
        with the mouse, (while holding down the Ctrl key and the left mouse
        button), to the destination point. You can drag checkers to open points
        or to points where you have checkers of the same color. You can also
        'hit' opponent blots with the drag and drop edit method.</para>
      <para>This method of editing comes handy when there is just a small
        adjustment to be done in the position.</para>
    </sect2>
    <sect2 id="gnubg-edit_turn">
      <title>Setting the player on turn</title>
      <para>The player on turn can be set by clicking the small checker icons
        below the board. See figure below.</para>
      <figure float="0" id="gnubg-fig_turn">
        <title>Clicking the White checker image will set White on turn, clicking
          the Black image will set Black in turn.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/setturn.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>Note that setting the turn sets the turn before the dice has been
        rolled. If there is a dice present at the board, setting the turn will
        remove the dice rolled. In this way you can set up a position to be a
        cube decision evaluation instead of a move decision evaluation.</para>
      <para>The turn can also be set by choosing <menuchoice><guimenu>Game</guimenu><guimenuitem>Set turn</guimenuitem></menuchoice>. Both these methods for setting the player on turn can
        also be used without being in edit mode.</para>
    </sect2>
    <sect2 id="gnubg-edit_dice">
      <title>Setting the dice</title>
      <para>You can set the dice for a player by clicking in the middle part of
        the board where you usually click when you roll the dice while playing.
        Click in the middle of the right playing area to set the dice for player
        0, the bottom player. Click the left dice rolling area to set the dice
        for player 1, the top player. Once you click one of these areas the dice
        selection widget will appear and you can select a dice roll by clicking
        on a dice pair.</para>
      <figure float="0" id="gnubg-fig_dice">
        <title>Click inside the red rectangle to set the dice for Black. Click
          inside the green rectangle to set the dice for White.</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/setdice.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>Setting the dice in edit mode sets both dice and the player on turn.
        Setting the dice for player 0, will make player 0 on turn with that
        specific dice roll to play.</para>
      <para>This method for setting the dice roll only works in edit mode. If
        you're not in edit mode you can set the dice by choosing <menuchoice><guimenu>Game</guimenu><guimenuitem>Set dice...</guimenuitem></menuchoice> from the menu, however this will set the dice for the
        player on turn.</para>
    </sect2>
    <sect2 id="gnubg-edit_cube">
      <title>Setting the cube</title>
      <para>Setting the cube is quite simple while you're in edit mode. Simply
        click the cube in the board and the cube selection widget appears.</para>
      <para>Selecting a cube in the first row, where the number is displayed
        up-side-down, the top player will be the cube owner. The value of the
        cube will be the value of the cube you click in the widget. Note that
        the unturned cube is the leftmost cube labeled 64, just as it usually is
        on real double cube.</para>
    </sect2>
    <sect2 id="gnubg-edit_score">
      <title>Setting the score</title>
      <para>Very often i backgammon the match score does matter on how the
        position is evaluated. <application>GNU Backgammon</application>'s
        evaluation algorithms does take the score into account. You can
        therefore adjust the the match length and the score to each player while
        you're in edit mode.</para>
      <para>In the figure you see that the score fields are editable while
        you're in edit mode. Insert the desired match score for each player in
        these fields. Player 0, the top player, has the left score field and
        player 1, the bottom player, has the right score. You can also set the
        match score in the in the match field to the right. There is also a box
        to tick whenever the position is from a Crawford game.</para>
      <para>If you want the computer to do a money game evaluation of the
        position, you should set the match score to 0 (zero).</para>
    </sect2>
    <sect2 id="gnubg-edit_exit">
      <title>Exiting Edit mode</title>
      <para>Before you can start analyzing the position you have to exit edit
        mode. This is done by releasing the Edit button in the toolbar by
        clicking it. Note that editing a position destroys your game record with
        no warning, so it might be an idea to save your match if you want to
        keep it.</para>
    </sect2>
    <sect2 id="gnubg-edit_analyze">
      <title>Analyzing the position</title>
      <para>After you have successfully set up the position you desire, you can
        now analyze the position. You can click Hint in the toolbar to get the
        best move of cube decision in the same way as described in the chapter
        called <xref linkend="gnubg-playing"/>. Hint, rollouts and evaluations done
        from the hint window will not be saved if you try to save the position.
        If you want to analyze the position and then be able to save the
        position and the analysis results you should rather do a move and then
        click back to the move and then choose <menuchoice><guimenu>Analyze</guimenu><guimenuitem>Analyze move</guimenuitem></menuchoice> for the menu. You can then work in the analysis pane on
        the right side instead of in the hint window.</para>
      <para>You can enter checkers on a point by clicking on the point. Notice
        the amount of checkers you add on a point, depends on where on that
        point you click. Left mouse button, black checkers and right mouse
        button, red checkers. (assuming you didn't change the colors). You will
        get used to this editing. and it makes it much faster to set up a
        position.</para>
      <para>See also <ulink url="http://www.bkgm.com/rgb/rgb.cgi?view+1098">Albert Silver's post on GammOnLine</ulink>
      </para>
    </sect2>
  </sect1>
  <sect1 id="gnubg-matches">
    <title>Working with matches</title>
    <sect2 id="gnubg-matches_ras">
      <title>Retrieving and storing backgammon files</title>
      <sect3 id="gnubg-matches_ras_sgff">
        <title>The Smart Game Format</title>
        <para><application>GNU Backgammon</application> uses the Smart Game
          Format (SGF) to store games, matches, sessions and positions. SGF is
          used in as a standard format for several other turn based games. The
          SGF files can store all the rolls and moves and cube decisions as well
          as commentary and analysis.</para>
        <para> A game that uses SGF extensively is Go. The format is described
          at <ulink url="http://www.red-bean.com/sgf/">this site</ulink>.
        </para>
      </sect3>
      <sect3 id="gnubg-matches_opening">
        <title>Opening and importing matches</title>
        <para>Since version 0.16 the GUI recognizes all importable files
          automatically (with the exception of the FIBS format). To open or
          import a file choose <menuchoice><guimenu>File</guimenu><guimenuitem>Open</guimenuitem></menuchoice>. A file dialog box will appear where you can select the
          file and the dialog will inform you of the recognized format, if the
          file is importable. You can also use the keyboard shortcut Ctrl-O, or
          the tool bar button labeled Open, to open the file dialog box
          directly.</para>
        <para>It is still possible to import an unrecognized file by using the
          underlying command line interface. Enable the command pane by choosing <menuchoice><guimenu>View</guimenu><guimenuitem>Command</guimenuitem></menuchoice>. In the command pane type in <command>import oldmoves
            &lt;filepath&gt;</command> to import, e.g., an oldmoves fibs
          formatted file.</para>
        <para>The following table contains the supported formats and the
          corresponding commands for manual import of a file.</para>
        <informaltable>
          <tgroup cols="2">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <tbody>
              <row>
                <entry>FIBS oldmoves format</entry>
<entry> <command>import oldmoves &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>Gamesgrid Save Game</entry>
<entry> <command>import sgg &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>GammonEmpire Game</entry>
<entry> <command>import empire &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>Hans Berliner's BKG Format</entry>
<entry> <command>import bkg &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>Jellyfish Game</entry>
<entry> <command>import gam &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>Jellyfish Match</entry>
<entry> <command>import mat &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>Jellyfish Position</entry>
<entry> <command>import pos &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>PartyGammon Game</entry>
<entry> <command>import party &lt;filepath&gt;</command> </entry> </row>
              <row>
                <entry>Snowie Text</entry>
<entry> <command>import snowietxt &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>True Moneygames</entry>
<entry> <command>import tmg &lt;filepath&gt;</command> </entry>
</row>
            </tbody>
          </tgroup>
        </informaltable>
      </sect3>
      <sect3 id="gnubg-matches_saving">
        <title>Saving and exporting positions, games or matches</title>
        <para>If you have played or imported a match into <application>GNU
            Backgammon</application>, and wish to save your efforts, you can
          choose <menuchoice><guimenu>File</guimenu><guimenuitem>Save</guimenuitem></menuchoice>. A file dialog box will appear and you can type in a
          file name or keep the suggested default file name. (The suggested
          default file name contains the date, the players name and the length
          of the match). This will save the whole match of the current match or
          session. If there is any analysis or commentary available this will
          also be saved to the file. You can also use the tool bar button
          labeled Save to open the file dialog box directly. There is also a
          keyboard shortcut, Ctrl-S, for saving a match or session.</para>
        <warning>
          <para>Please note that saving a position will not save any
          analysis.</para>
        </warning>
        <para>The export dialog is accessed by choosing <menuchoice><guimenu>File</guimenu><guimenuitem>Export</guimenuitem></menuchoice> This dialog is similar to the save dialog. Again you may
          choose a different filename and whether to export an entire match, a
          game or a position. Then you must choose an export format as well.
          Notice some file formats only supports export of matches and some only
          supports position. Only when a legal combination is chosen will ending
          the dialog be possible. The following table contains the supported
          file formats and the corresponding commands for export. Again notice
          that with some formats only some of M(atch), G(ame), P(osition) is
          allowed. For example to export a Jellyfish position you would issue
          the command <command>export position pos
          &lt;filepath&gt;</command></para>
        <informaltable>
          <tgroup cols="2">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <tbody>
              <row>
                <entry>Encapsulated Postscript</entry>
<entry> <command>export &lt;P&gt; eps &lt;filepath&gt;</command> </entry>
              </row>
              <row>
                <entry>HTML</entry>
<entry> <command>export &lt;MGP&gt; html &lt;filepath&gt;</command> </entry>
              </row>
              <row>
                <entry>Jellyfish Game</entry>
<entry> <command>export &lt;G&gt; gam &lt;filepath&gt;</command> </entry>
              </row>
              <row>
                <entry>Jellyfish Match</entry>
<entry> <command>export &lt;M&gt; mat &lt;filepath&gt;</command> </entry>
              </row>
              <row>
                <entry>Jellyfish Position</entry>
<entry> <command>export &lt;P&gt; pos &lt;filepath&gt;</command> </entry>
              </row>
              <row>
                <entry>LaTeX</entry>
<entry> <command>export &lt;MG&gt; latex &lt;filepath&gt;</command> </entry>
              </row>
              <row>
                <entry>PDF</entry>
<entry> <command>export &lt;MG&gt; pdf &lt;filepath&gt;</command> </entry>
              </row>
              <row>
                <entry>Plain Text</entry>
<entry> <command>export &lt;MGP&gt; text &lt;filepath&gt;</command> </entry>
              </row>
              <row>
                <entry>Portable Network Graphics</entry>
<entry> <command>export &lt;P&gt; pdf &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>PostScript</entry>
<entry> <command>export &lt;MG&gt; postscript &lt;filepath&gt;</command> </entry>
</row>
              <row>
                <entry>Snowie Text</entry>
<entry> <command>export &lt;P&gt; snowietxt &lt;filepath&gt;</command>
                </entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <sect4 id="gnubg-matches_saving_html">
          <title>HTML export</title>
          <para><application>GNU Backgammon</application> can export the current
            position, game, match or session in HTML if you wish to publish it
            on the web. </para>
          <para><application>GNU Backgammon</application> exports in validating
            XHTML 1.0 with the use of CSS style sheets. You may add your own
            style sheet to the exported HTML files if you wish to override the
            default layout, e.g., change colors or fonts.</para>
          <para>The board is made up from hundreds of pictures. Currently, you
            can choose between three different sets of pictures:</para>
          <orderedlist continuation="restarts" inheritnum="ignore">
            <listitem>
              <para>the BBS images used by Kit Woolsey's GammOnLine e-magazine,
                Danish Backgammon Federation's web-based discussion group and
                others </para>
            </listitem>
            <listitem>
              <para>the fibs2html images used by the Joseph Heled's program
                  <ulink url="http://fibs2html.sf.net/">fibs2html</ulink>
              </para>
            </listitem>
            <listitem>
              <para>images generated by <application>GNU
                Backgammon</application> itself. </para>
            </listitem>
          </orderedlist>
          <para>The images generated by <application>GNU
            Backgammon</application> will use your current board design in
              <application>GNU Backgammon</application>, and honors your
            settings on clockwise or anti-clockwise movement and board numbering
            (on, off, dynamic).</para>
          <para>If you export a match or session to HTML, <application>GNU
              Backgammon</application> will write the individual games to
            separate files. For example, if you export to file foo.html the
            first game is exported to foo.html, the second game to foo_002.html,
            the third game to foo_003.html and so forth.</para>
          <para>The output from the HTML export can be customized. For example,
            it's possible to leave out the analysis or parts of the analysis.
            Also, you may enter a specific URL to the pictures used to compose
            the board which is useful for posting positions on web-based
            discussion groups such as Kit Woolsey's GammOnLine, the Danish
            Backgammon Federation's Debat Forum, or you may opt to use a default
            set of images available from the <ulink url="http://www.gnubg.org/images/html-images/">gnubg.org</ulink>
            web site.</para>
          <para>If you want to have html images locally on your computer, you
            can have <application>GNU Backgammon</application> generate these.
            The html images will be generated based on the current appearance
            settings. You can also control the size of the images in the export
            settings dialog (To get the export settings dialog you can select in
            the menu <menuchoice><guimenu>Settings</guimenu><guimenuitem>Export...</guimenuitem></menuchoice>. Select the size of your html images at the bottom
            right in this dialog</para>
          <para>To start the generation of the html images, select in the menu <menuchoice><guimenu>File</guimenu><guimenuitem>Export</guimenuitem><guimenuitem>HTML images...</guimenuitem></menuchoice>. In the file dialog box, you can select a
              <emphasis>directory</emphasis> where the images will be generated.
            The images are stored in PNG format.</para>
          <para>To generate images for the command line, use the command:</para>
          <para>export htmlimages directory</para>
          <para>where directory is the directory where you want your images to
            be created.</para>
        </sect4>
        <sect4 id="gnubg-matches_saving_latex">
          <title>LaTeX export</title>
          <para><application>GNU Backgammon</application> can export games,
            match and positions to the document typesetting system LaTeX. For
            exporting a match or session to LaTeX</para>
          <para>The LaTeX export will export all board diagrams and analysis if
            available. The produced documents can therefore be quite large. Note
            that the LaTeX file produced needs the eepic package. You can get
            this package at your nearest CTAN mirror((The produced LaTeX file
            also needs epic, textcomp and ucs, but these are more common in
            LaTeX distributions so you probably already have these.)).</para>
          <para>You can not export a position to LaTeX. (At least not yet!)
            However, you can export a position to EPS and include this EPS file
            in your LaTeX document.</para>
        </sect4>
      </sect3>
    </sect2>
    <sect2 id="gnubg-matches_entering">
      <title>Entering live tournament matches</title>
      <para>It's possible to enter match transcriptions into <application>GNU
          Backgammon</application>. It's not very difficult. Presuming you're
        using the GUI, do this:</para>
      <orderedlist continuation="restarts" inheritnum="ignore">
        <listitem>
          <para>Start a match of any length, pressing the New button, and select
            Human-Human and manual dice. </para>
        </listitem>
        <listitem>
          <para>To select the opening roll, click on the right dice pair in the
            dice selection window that appears. The left die in the dice pair is
            the die that's rolled by player 0, or the player at the top. The
            right die is the die that will be rolled by player 1 or the bottom
            player. So if you select for example the 53 dice combination it
            means that player 0 rolls a 5 and player 1 rolls a 3, and player 0
            is therefore beginning this game. However, if you select the 35 dice
            combination it means that player 0 rolls a 3 and player 1 rolls a 5.
            Player 1 will therefore begin when you select 53 instead of 35.
          </para>
        </listitem>
        <listitem>
          <para>To change the names, use the Edit button at the top. If you want
            to enter information such as the name of the Annotator, date,
            locale, etc. go to the Game menu and choose Match Information.
          </para>
        </listitem>
        <listitem>
          <para>To enter written comments, you first have to play the move, and
            then go back to the move in the move list to be able to use the
            Commentary pane (feel free to close the Messages pane from the
            Windows menu). Don't forget to save the match every once in a while.
          </para>
        </listitem>
        <listitem>
          <para>One comment: when entering the Cube commentary of a cube play
            (meaning it was turned), select the Take/Pass decision to enter the
            commentary. The reason is that if you export it after, and didn't do
            this, the commentary appears before the cube decision and not after
            as it should. </para>
        </listitem>
      </orderedlist>
      <para>Tip: while entering the match, if you wish to see <application>GNU
          Backgammon</application>'s opinion while you are entering the moves,
        play the move on the board and press the Hint button in the tool bar. In
        the latest builds, if you have done this, the results will then be
        placed with the move so that it means it is already analyzed when you
        run the full match analysis. Mind you, it will preserve the information
        even if you ran a deeper 3-ply or 4-ply from the Hint window. After
        playing the move and confirming the dice, go back in the move list and
        click on the move, and you'll see the analysis appear in the Analysis
        pane as it should.</para>
      <sect3 id="gnubg-matches_entering_illegal">
        <title>Entering illegal moves</title>
        <para>It's possible to enter illegal moves with a little trick. This is a
        step by step guide for the example: If a player rolls 41 and the player
        makes an illegal move as the dice showed 31.</para>
        <orderedlist continuation="restarts" inheritnum="ignore">
          <listitem>
            <para>Manually enter the roll which was rolled. 41. </para>
          </listitem>
          <listitem>
            <para>Do a legal move with 41 (this is just to get the analysis of the
            roll, and the best legal move.) </para>
          </listitem>
          <listitem>
            <para>Click the dice to pick them up and complete the move. </para>
          </listitem>
          <listitem>
            <para>Now, before you roll the opponents dice, click the Edit button.
          </para>
          </listitem>
          <listitem>
            <para>While holding down the CTRL-button on your keyboard, you can now
            drag the checkers to the resulting illegal position which was played
            over the board. </para>
          </listitem>
          <listitem>
            <para>Release the Edit button to exit edit mode. </para>
          </listitem>
          <listitem>
            <para>Make sure the right player is on turn, by clicking on the
            checker image for the player on roll, under the game board. </para>
          </listitem>
          <listitem>
            <para>Continue to enter the rest of the game. </para>
          </listitem>
        </orderedlist>
      </sect3>
    </sect2>
    <sect2 id="gnubg-matches_analysing">
      <title>Analyzing matches</title>
      <para><application>GNU Backgammon</application> can analyze your matches
        for skill and luck. If you have an open match (as a result of playing,
        loading or importing), the analysis is started by choosing <menuchoice><guimenu>Analyze</guimenu><guimenuitem>Analyze match</guimenuitem></menuchoice>. You should now see a progress bar at the bottom right
        corner of the main interface window while the computer is busy
        analyzing. During this time you won't be able to interact with the
        program other than to quit the analysis. The analysis is complete when
        the progress bar disappears and you hear a small sound. Now, you would
        probably like to view the result of the analysis. This can be done in
        terms of overall statistics by choosing <menuchoice><guimenu>Analyze</guimenu><guimenuitem>Match statistics</guimenuitem></menuchoice>, or in detail by browsing through the match. More on these
        subjects in the upcoming sections.</para>
      <para>You can also analyze just the current game, by choosing <menuchoice><guimenu>Analyze</guimenu><guimenuitem>Analyze game</guimenuitem></menuchoice>. If you're only interested in the analysis of the current
        move, you can select <menuchoice><guimenu>Analyze</guimenu><guimenuitem>Analyze move</guimenuitem></menuchoice>.</para>
      <sect3 id="gnubg-matches_analysing_settings">
        <title>Analysis settings</title>
        <para>You can configure how <application>GNU Backgammon</application>
        analysis the match or game for you. This can be configured in the dialog
        box that appears when choose <menuchoice><guimenu>Settings</guimenu><guimenuitem>Analysis</guimenuitem></menuchoice>.</para>
        <figure float="0" id="gnubg-fig_analyze">
          <title>Analyze settings dialog</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/analysesettings.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>In the top left frame in this dialog box, you can select what to
        analyze. <application>GNU Backgammon</application> is able to analyze
        three different properties in a match.</para>
        <orderedlist continuation="restarts" inheritnum="ignore">
          <listitem>
            <para>Checker play </para>
          </listitem>
          <listitem>
            <para>Cube decisions </para>
          </listitem>
          <listitem>
            <para>Luck of each roll </para>
          </listitem>
        </orderedlist>
        <para>In addition you can have the analysis to analyze just one of the
        players, or both. There is also possible to set a limit of how many
        moves to be analyzed at each position. When you're reviewing your match,
        the number of analyzed moves will be limited to number in this field.
        However, if you want to analyze further moves in a particular position,
        it's not a problem to do that later. The move that was actually done in
        the match will be analyzed even if it is ranked below the number of
        moves limit.</para>
        <para><application>GNU Backgammon</application> will also mark each move
        or cube decision with Doubtful, Bad and Very bad. You can adjust the
        limits in equity difference for which label to assign. This is done in
        the frame box to the left. Notice, currently the Good and Very good
        classes are not used.</para>
        <para>You can also adjust the classes for what <application>GNU
        Backgammon</application> considers lucky and unlucky rolls. The luck of
        a roll is defined as the difference of equity after the best move after
        rolled dice and the equity after best move averaged over all possible
        rolls.</para>
        <para>The right part of the dialog box is an evaluation setting for how
        each move or cube decision should be evaluated in the analysis. For an
        explanation of this settings, see the chapter called "[[Evaluation
        settings]]".</para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-matches_review">
      <title>Reviewing matches</title>
      <sect3 id="gnubg-matches_review_record">
        <title>Game record</title>
        <para>When a match is analyzed in <application>GNU
          Backgammon</application> you should open the <emphasis>game
          record</emphasis> window. Open this by checking <menuchoice><guimenu>Window</guimenu><guimenuitem>Game record</guimenuitem></menuchoice> on from the main menu. The game record window can also
          be docked into the right side panel. If you want it docked into the
          right side panel you should check on <menuchoice><guimenu>Window</guimenu><guimenuitem>Dock panels</guimenuitem></menuchoice>. The game record window shows a list of all the moves in
          the game. You can also navigate between the games and moves.</para>
        <figure float="0" id="gnubg-fig_record">
          <title>The Game record pane</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/gamerecord.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>The figure shows a typical game record list. The moves are shown
          in two columns. The left column shows the moves for player 0,the to
          player, and the right column shows the moves of player 1, the bottom
          player. You can navigate through the game with the arrow buttons at
          the top of the game record. The red buttons with the double arrows
          take you to the previous game or the next match. (Arrow pointing to
          the left takes you to the previous game, and the red arrow pointing to
          the right takes you to the next game.) The green buttons take you one
          move ahead in the game or one move back. The green arrow button
          pointing to the right take you to the previous move. The green arrow
          button pointing to the right take you to the next move or to the next
          dice roll. If your in the move list where the dice is not rolled, a
          click on this green Next button will show you the same position with
          the dice rolled. The last two buttons take you to the next marked
          move, or to the previous marked move. The green arrow button with a
          question mark pointing to the left will take you to the previous
          marked move. The green arrow button with a question mark pointing to
          the right will take you to the next marked move. You can also go to
          other games in the match or session by selecting the game in the game
          drop down menu. You can also go to a move directly by clicking that
          move in the game record list.</para>
        <para>There is also some keyboard shortcuts for navigating through the
          match. Page Down till take you to the next move and Page up will take
          you to the previous move.</para>
        <para>After a analysis some of the move in the game list will be marked.
          You will see some moves marked with <emphasis>?</emphasis> and some
          with <emphasis>?!</emphasis> and some with <emphasis>??</emphasis>.
          These marks means the same as the marks in normal chess notation.</para>
        <informaltable frame="all">
          <tgroup cols="2">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <tbody>
              <row>
                <entry>??</entry>
                <entry>a very bad move</entry>
              </row>
              <row>
                <entry>?</entry>
                <entry>a bad move</entry>
              </row>
              <row>
                <entry>?!</entry>
                <entry>a doubtful move</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <para>Note that it is the same marks for cube decisions as for checker
          moves. Nevertheless, checker moves marks are before the cube decisions
          marks. If no mark exists for checker move, the cube mark is separated
          by two spaces.</para>
        <para>In newer builds of <application>GNU Backgammon</application> the
          various moves also get a color code. The cube decisions are shown by
          the background color. The checkers move decisions are shown by the
          font color.</para>
        <informaltable frame="all">
          <tgroup cols="3">
            <tbody>
              <row>
                      <entry></entry>
                      <entry>Cube(background)</entry>
                      <entry>Move(font)</entry>
              </row>
              <row>
                      <entry>Very Bad</entry>
                <entry>Yellow</entry>
                <entry>Red</entry>
              </row>
              <row>
                      <entry>Bad</entry>
                <entry>Pink</entry>
                <entry>Blue</entry>
              </row>
              <row>
                      <entry>Doubtful</entry>
                <entry>Grey</entry>
                <entry>Green</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <para>The luck is also marked in the font</para>
        <informaltable frame="all">
          <tgroup cols="2">
            <tbody>
              <row>
                      <entry>Luck</entry>
                <entry>Font</entry>
              </row>
              <row>
                      <entry>Very Lucky</entry>
                <entry>Bold</entry>
              </row>
              <row>
                      <entry>Very Unlucky</entry>
                <entry>Italics</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
      </sect3>
      <sect3 id="gnubg-matches_review_analysis">
        <title>Analysis panel</title>
        <para>You can also study your moves and cube decisions in more detail in
          the analysis window, or analysis panel if you have checked Dock panels
          in the Window menu. You can open this window by checking on <menuchoice><guimenu>Window</guimenu><guimenuitem>Analysis</guimenuitem></menuchoice>. If you have docked panels the analysis panel will
          appear under the game record. The analysis window is basically the
          same as the Hint window described in the "[[Playing a game or match]]"
          chapter.</para>
        <figure float="0" id="gnubg-fig_analyzepane">
          <title>The Analyze pane</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/analysepane.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>In the figure you can see the analysis panel. At the top of the
          analysis panel you will see three pull-down menus. The leftmost
          pull-down menu is a comment on the cube decision. In the figure it is
          a position where the player didn't double and the <application>GNU
            Backgammon</application>'s analysis of this is empty. There was
          nothing wrong with not doubling in this position. The user can also
          override <application>GNU Backgammon</application>'s evaluation and
          mark the cube decision as 'Doubtful', 'Bad' or 'Very bad'. Note that
          the cube decision pull-down menu will only be visible when the player
          has the cube available.</para>
        <para>The next pull-down menu shows a simple analysis of the roll. The
          roll in this position was 32. <application>GNU
          Backgammon</application>'s evaluation of this dice roll is also empty.
          It shows that this particular roll was -.162 equity worse than the
          average roll. This means that the roll is a bit unlucky, but does not
          qualify for being marked as an unlucky roll. The rolls are marked in
          these categories: 'Very lucky', 'Lucky', 'Unlucky' and 'Very unlucky'.</para>
        <para>The rightmost pull-down menu, shows the move which was done. In
          this situation the move that was done was 3/off 2/off. This move did
          not qualify for any mark. Moves that <application>GNU
          Backgammon</application> don't like will be marked as 'Doubtful',
          'Bad' or 'Very bad'. The user can also override <application>GNU
            Backgammon</application>'s evaluation and mark the move manually
          with the pull-down menu.</para>
        <para>The rest of the analysis window is a notebook of two pages. The
          first page is the list of possible moves. The list is sorted in the
          ranked order with the best considered move at the top. The moves are
          sorted by equity or EMG. In the list in the figure there is only two
          possible moves. The move that was actually done in the match, is
          marked with red color. The only difference of this list of moves and
          the list of moves in the hint window, is that this list does not show
          the probabilities for each outcome of the game. If you want to see the
          probabilities of the different outcomes, you can click on the button
          labeled Details. This will then show you a list with these numbers.</para>
        <para>The other page of the notebook is the cube decision analysis. This
          analysis show exactly the same as in the Hint window described in the
          chapter called "[[Playing a game or match]]". Note that the cube
          decision page will only be available if there is a cube decision. It
          will not be visible if the cube is not available to the player.</para>
        <para>There is also a set of tool buttons in the analysis panel. These
          buttons does exactly the same as the tool buttons in the Hint window,
          which is described in the the chapter called "[[Playing a game or
          match]]".</para>
      </sect3>
      <sect3 id="gnubg-matches_review_stat">
        <title>Statistics</title>
        <para>You can get a summary of the analysis from the game, match, or
          session analysis. The game analysis is a summary for the current game
          whereas the match or session statistics is a summary of all the games
          in the match or session. The match analysis is available in the GUI
          from <menuchoice><guimenu>Analyze</guimenu><guimenuitem>Match Statistics</guimenuitem></menuchoice> or at the bottom of exported files.</para>
        <sect4 id="gnubg-matches_review_stat_check">
          <title>Checker play statistics</title>
          <para>This section provides a summary of the checker play statistics.
            The following information is available</para>
          <orderedlist continuation="restarts" inheritnum="ignore">
            <listitem>
              <para>Total moves: The total number of moves in the match. </para>
            </listitem>
            <listitem>
              <para>Unforced moves: The number of unforced moves, i.e., all
                checker play decisions which had more than one legal move.
              </para>
            </listitem>
            <listitem>
              <para>Moves marked <emphasis>xxx</emphasis>: The number of moves
                marked <emphasis>very good</emphasis>, <emphasis>very
                bad</emphasis> etc. The analysis will mark moves <emphasis>very
                  bad</emphasis>, <emphasis>bad</emphasis> etc. based on the
                threshold you've defined in the analysis settings.
                  <application>GNU Backgammon</application> can currently not
                automatically mark moves, e.g., <emphasis>good</emphasis>, but
                you can mark moves <emphasis>good</emphasis> yourself. </para>
            </listitem>
            <listitem>
              <para>Error rate (total): The first number is the total amount of
                normalized equity that the player gave up during this game or
                match. The number in parenthesis is the un-normalized
                counterpart; for money play the all errors are multiplied with
                the value of the cube, and for match play the total match
                winning chance given up by the player is reported. </para>
            </listitem>
            <listitem>
              <para>Error rate (per move): The error rate per move is the total
                error rate divided by the number of <emphasis>unforced
                moves</emphasis>. Note that is different from Snowie 4 that
                defines the error rate per move as the total error rate divided
                by the total number of moves for both players, i.e., the sum of
                  <emphasis>total moves</emphasis> for both players. In general,
                your error rate per move will be lower in Snowie than in
                  <application>GNU Backgammon</application>. </para>
            </listitem>
            <listitem>
              <para>Checker play rating: <application>GNU
                Backgammon</application> will assign a rating for your checker
                play ranging from <emphasis>Awful!</emphasis> to
                  <emphasis>Supernatural</emphasis>. See the description for the
                overall rating below. </para>
            </listitem>
          </orderedlist>
        </sect4>
        <sect4 id="gnubg-matches_review_stat_luck">
          <title>Luck analysis</title>
          <para>This section provides information about how Ms. Fortuna
            distributed her luck. The following information is available:</para>
          <orderedlist continuation="restarts" inheritnum="ignore">
            <listitem>
              <para>Rolls marked <emphasis>xxx</emphasis>: The number of moves
                marked <emphasis>very lucky</emphasis>,
                <emphasis>lucky</emphasis> etc. Moves marked <emphasis>very
                  lucky</emphasis> are huge jokers that improve your equity with
                more the +0.6 relative to the average equity. <application>GNU
                  Backgammon</application> normally uses cubeful 0-ply
                evaluations to calculate the luck, but you can change that under
                the analysis settings. See below for a complete overview of what
                is considered <emphasis>very lucky</emphasis>,
                <emphasis>lucky</emphasis>, etc. </para>
            </listitem>
            <listitem>
              <para>Luck rate (total): The total luck for this game or match
                reported both normalized and unnormalized. </para>
            </listitem>
            <listitem>
              <para>Luck rate (per move): The luck rate per move reported both
                normalized and unnormalized. </para>
            </listitem>
            <listitem>
              <para>Luck rating: Based on the luck rate per move
                  <application>GNU Backgammon</application> will assign you a
                humorous luck rating. See below for the possible ratings.
              </para>
            </listitem>
          </orderedlist>
          <para>Thresholds for marking of rolls:</para>
          <informaltable frame="all">
            <tgroup cols="2">
              <colspec colname="c1" colnum="1" colwidth="1*"/>
              <colspec colname="c2" colnum="2" colwidth="1*"/>
              <tbody>
                <row>
                  <entry>Deviation of equity from average</entry>
                  <entry>Roll is marked</entry>
                </row>
                <row>
                  <entry>&gt; 0.6</entry>
                  <entry>very lucky</entry>
                </row>
                <row>
                  <entry>0.3 - 0.6</entry>
                  <entry>lucky</entry>
                </row>
                <row>
                  <entry>-0.3 - 0.3</entry>
                  <entry>unmarked</entry>
                </row>
                <row>
                  <entry>-0.6 - -0.3</entry>
                  <entry>unlucky</entry>
                </row>
                <row>
                  <entry>&lt; -0.6</entry>
                  <entry>very unlucky</entry>
                </row>
              </tbody>
            </tgroup>
          </informaltable>
          <para>Luck ratings:</para>
          <informaltable frame="all">
            <tgroup cols="2">
              <colspec colname="c1" colnum="1" colwidth="1*"/>
              <colspec colname="c2" colnum="2" colwidth="1*"/>
              <tbody>
                <row>
                  <entry>Normalized luck rate per move</entry>
                  <entry>Luck rating</entry>
                </row>
                <row>
                  <entry>&gt; 0.10</entry>
                  <entry>Cheater :-)</entry>
                </row>
                <row>
                  <entry>0.06 - 0.10</entry>
                  <entry>Go to Las Vegas immediately</entry>
                </row>
                <row>
                  <entry>0.02 - 0.06</entry>
                  <entry>Good dice, man!</entry>
                </row>
                <row>
                  <entry>-0.02 - 0.02</entry>
                  <entry>none</entry>
                </row>
                <row>
                  <entry>-0.06 - -0.02</entry>
                  <entry>Better luck next time</entry>
                </row>
                <row>
                  <entry>-0.06 - -0.10</entry>
                  <entry>Go to bed</entry>
                </row>
                <row>
                  <entry>&lt; -0.10</entry>
                  <entry>Haaa-haaa</entry>
                </row>
              </tbody>
            </tgroup>
          </informaltable>
        </sect4>
        <sect4 id="gnubg-matches_review_stat_cube">
          <title>Cube statistics</title>
          <para>This section provides a summary of the cube decision statistics:
            the number of cube decisions, missed doubles, etc.</para>
          <orderedlist continuation="restarts" inheritnum="ignore">
            <listitem>
              <para>Total cube decisions: The total number of cube decisions,
                i.e., the sum of no-doubles, doubles, takes, and passes. </para>
            </listitem>
            <listitem>
              <para>Close or actual cube decisions: Similar to Total cube
                decisions, except that no-doubles are only included if they're
                considered <emphasis>close</emphasis>. <application>GNU
                  Backgammon</application> considers a cube decision close if
                the relevant equities are within 0.25 from each other or if the
                position is too good. </para>
            </listitem>
            <listitem>
              <para>Doubles, Takes, Passes: The total number of doubles, takes,
                and passes in the game or match. </para>
            </listitem>
            <listitem>
              <para>Missed doubles around DP, Missed doubles around TG: The
                number of missed doubles around the double point and too good
                point respectively. If the equity is below 0.95 the position is
                considered to be around the double point else it considered to
                be around the too good point. If you miss doubles around the
                double point, it usually means that you double too late, whereas
                missed doubles around the too good point means that you're too
                greedy and play on for gammon when the position is
                <emphasis>not</emphasis> too good. </para>
            </listitem>
            <listitem>
              <para>Wrong doubles around DP, Wrong doubles around TG: The number
                of wrong doubles around the double point and too good point,
                respectively. If you have wrong doubles around the double point
                that generally means that you double too early where you really
                should hold the cube, whereas wrong doubles around the too good
                point means that you double positions where you really should
                play on for a gammon or backgammon. </para>
            </listitem>
            <listitem>
              <para>Wrong takes, Wrong passes: The total number of wrong takes
                and passes, respectively. </para>
            </listitem>
            <listitem>
              <para>Error rate (total): The accumulated cube errors for this
                game or match reported both normalized and unnormalized. </para>
            </listitem>
            <listitem>
              <para>Error rate (per cube decision): The error rate per cube
                decision is the total error rate divided by the number of
                  <emphasis>close or actual cube decisions</emphasis>. Note that
                is different from Snowie 4 that defines the error rate per cube
                decision as the total error rate divided by the total number of
                moves for both players. In general, your error rate per cube
                decision will be lower in Snowie than in <application>GNU
                  Backgammon</application>. Note that the reported number is
                multiplied by 1000 in the default settings. </para>
            </listitem>
            <listitem>
              <para>Cube decision rating: <application>GNU
                Backgammon</application> will assign a rating for your cube
                decisions ranging from <emphasis>Awful!</emphasis> to
                  <emphasis>Supernatural</emphasis>. See the description for the
                overall rating below. </para>
            </listitem>
          </orderedlist>
        </sect4>
        <sect4 id="gnubg-matches_review_stat_overall">
          <title>Overall rating</title>
          <para>The last section is the overall summary.</para>
          <orderedlist continuation="restarts" inheritnum="ignore">
            <listitem>
              <para>Error rate (total): The accumulated checker play and cube
                decision errors reported by normalized and unnormalized. </para>
            </listitem>
            <listitem>
              <para>Error rate (per decision): The error rate per decision is
                the total error rate divided by the number of non-trivial
                decisions (i.e., the sum of <emphasis>unforced moves</emphasis>
                and <emphasis>close or actual cube decisions</emphasis>). Again,
                please note that is different from Snowie 4 that defines the
                error rate per decision as the total error rate divided by the
                total number of moves for both players. In general, your error
                rate per move will be lower in Snowie than in <application>GNU
                  Backgammon</application>. An investigation of approximately
                300 matches showed the on average the <application>GNU
                  Backgammon</application> error rate with be 1.4 times higher
                than your Snowie 4 error rate. </para>
            </listitem>
            <listitem>
              <para>Equivalent Snowie error rate: For easy comparison
                  <application>GNU Backgammon</application> will also print the
                total error rate calculated by the same formula as Snowie 4.
              </para>
            </listitem>
            <listitem>
              <para>Overall rating: Based on your normalized error rate per move
                GNU Backgammon will assign you a rating ranging from
                  <emphasis>Awful!</emphasis> to
                <emphasis>Supernatural</emphasis>. See the table below for the
                thresholds. </para>
            </listitem>
            <listitem>
              <para>Actual result: The actual result of the game or match. For
                money game this is simply the number of points won or lost
                during the game or match. For match play the number is
                calculated as 50% added to the result of the game or match in
                MWC. For example, losing a match or winning a match corresponds
                to an actual result of 0% and 100%, respectively. Winning 1
                point in the first game of 7 point match is worth 6% using Kit
                Woolsey's match equity table, hence the actual result is 56%.
              </para>
            </listitem>
            <listitem>
              <para>Luck adjusted result: The luck adjusted result is calculated
                as the <emphasis>actual result</emphasis> plus the total
                unnormalized luck rate. This is also called <emphasis>variance
                  reduction of skill</emphasis> as described in Douglas Zare's
                excellent article <ulink url="http://math.columbia.edu/~zare/vrskill.html">Hedging
                  Toward Skill</ulink>. This should give an unbiased measure of
                the strengths of the players. </para>
            </listitem>
            <listitem>
              <para>MWC against current opponent: For match play
                  <application>GNU Backgammon</application> will calculate your
                MWC against the current opponent. The number is calculated as
                50% - your total unnormalized error rate + your opponent's total
                unnormalized error rate. If your opponent is really lucky but
                plays rather bad, this number can become larger than 100%, since
                he due to the extra luck has the possibly to give up even more
                MWC. However, <application>GNU Backgammon</application> will
                report this number as 100%, and 0% for the opposite situation.
                Note that this number is biased towards the analyzing bot, e.g.,
                a 0-ply analysis a game between GNU Backgammon 2-ply and 0-ply
                will suggest that 0-ply is a favorite, which it is clearly not.
                For an unbiased measure use the <emphasis>luck adjusted
                result</emphasis> above. </para>
            </listitem>
          </orderedlist>
          <para>Threshold for ratings:</para>
          <informaltable frame="all">
            <tgroup cols="2">
              <colspec colname="c1" colnum="1" colwidth="1*"/>
              <colspec colname="c2" colnum="2" colwidth="1*"/>
              <tbody>
                <row>
                  <entry>Normalized total error rate per move</entry>
                  <entry>Rating</entry>
                </row>
                <row>
                  <entry>0.000 - 0.002</entry>
                  <entry>Supernatural</entry>
                </row>
                <row>
                  <entry>0.002 - 0.005</entry>
                  <entry>World Class</entry>
                </row>
                <row>
                  <entry>0.005 - 0.008</entry>
                  <entry>Expert</entry>
                </row>
                <row>
                  <entry>0.008 - 0.012</entry>
                  <entry>Advanced</entry>
                </row>
                <row>
                  <entry>0.012 - 0.018</entry>
                  <entry>Intermediate</entry>
                </row>
                <row>
                  <entry>0.018 - 0.026</entry>
                  <entry>Casual Player</entry>
                </row>
                <row>
                  <entry>0.026 - 0.035</entry>
                  <entry>Beginner</entry>
                </row>
                <row>
                  <entry>&gt; 0.035</entry>
                  <entry>Awful!</entry>
                </row>
              </tbody>
            </tgroup>
          </informaltable>
          <para>Please note: The Normalized total error rate per move is
            multiplied by 1000 in the default settings.</para>
        </sect4>
      </sect3>
    </sect2>
  </sect1>
  <sect1 id="gnubg-rollouts">
    <title>Rollouts</title>
    <sect2 id="gnubg-rollouts_intro">
      <title>Introduction to rollouts</title>
      <para>The million dollar question is simple enough: out of all the games
        that could result from playing this position, how many do we win (and
        how many of our wins and losses are gammons, and how many are
        backgammons)? The model is exactly the same as if we had an urn with a
        googol balls in it (it's a big urn), and many of the balls have win
        written on them, and some say gammon loss, and if we look hard enough
        there are a few that read backgammon win, and so on. ((Balls and urns
        are to probability theorists what teapots and checkerboards are to
        computer graphics researchers, or <emphasis>squeamish
        ossifrage</emphasis> is to cryptographers – they seem to come with the
        territory.)) Instead of having the patience to count the googol balls,
        we just give the urn a really good shake and then pull 100 balls out
        without looking, and say for instance "Well, I got 53 wins, 31 losses, 9
        gammon wins, 6 gammon losses, and a backgammon win – looks like my
        equity's roughly +0.26." and go home. If we were a bit more thorough, we
        could go a bit further and figure out that by cheating and measuring the
        sample proportions instead of the population proportions, we introduced
        a standard error of 0.06 into our result. (Of course, the trick is to
        select a sample size that's big enough that you reduce the standard
        error to a tolerable level, but small enough that the answer arrives
        before you get bored.)</para>
      <para>It will come as no surprise that a rollout with a limited number of
        trials follows exactly the same procedure. It's sufficient to say that
        the proportion of wins/gammons etc. that come up when <application>GNU
          Backgammon</application> plays against itself (say) 1296 times, aren't
        likely to vary all that much from the proportion we would get if we
        measured the proportion of results in every game we could possibly get
        of <application>GNU Backgammon</application> playing against itself. (Of
        course, there may still be some doubt whether the results of
          <application>GNU Backgammon</application> vs. <application>GNU
          Backgammon</application> are representative of the results of a
        perfect player vs. a perfect player, or of you vs. Joe Average, but
        that's another story.)</para>
    </sect2>
    <sect2 id="gnubg-rollouts_gnubg">
      <title>Rollouts in <application>GNU Backgammon</application></title>
      <para>In <application>GNU Backgammon</application> the Rollout function
        implements the procedure described above, with the following
        improvements:</para>
      <orderedlist continuation="restarts" inheritnum="ignore">
        <listitem>
          <para>Truncation: instead of rolling out all the way to the end of the
            game, it can stop and pretend its evaluation after a few plies is
            perfect. This may obviously introduce some amount of systematic
            error, but in practice this may not matter because: </para>
        </listitem>
        <listitem>
          <para>it makes rollouts much faster, which means you can do more of
            them (and thus trade sampling error for systematic error); </para>
        </listitem>
        <listitem>
          <para>different positions will be reached in different trials, so the
            correlation between errors in each trial weakens and the errors
            cancel out to some extent; </para>
        </listitem>
        <listitem>
          <para>if you are rolling out the positions after making different
            plays, then any remaining systematic error between the two rollouts
            is likely to be somewhat correlated and so the error in the
            comparison between the plays is hopefully small. This implies that
            truncated rollouts are better for estimating
            <emphasis>relative</emphasis> equity (<emphasis>which is the better
              move here, 13/10*/9 or 13/10* 6/5*?</emphasis>) than
              <emphasis>absolute</emphasis> equity (<emphasis>at this match
              score I need 29% wins to accept a dead cube; can I take in this
              position?</emphasis>). </para>
        </listitem>
        <listitem>
          <para>Race database truncation: when the game enters its 2-sided
            bearoff database, <application>GNU Backgammon</application> can
            estimate the probability of winning from that position with no error
            at all (it can play and evaluate endgame positions perfectly), which
            saves time and avoids introducing the errors that can result from
            large equity variances at the end of the game. </para>
        </listitem>
        <listitem>
          <para>Variance reduction: when using lookahead evaluations, it can
            reduce errors by making use of the equity difference from one ply to
            the next. (This can be interpreted as either canceling out the
            estimated <emphasis>luck</emphasis> (i.e. the difference in equity
            evaluations before and after rolling) or using subsequent
            evaluations to estimate the error in prior ones; the two views are
            equivalent). <application>GNU Backgammon</application> automatically
            performs variance reduction when looking ahead at least one ply.
          </para>
        </listitem>
        <listitem>
          <para>Stratified sampling: uses quasi-random number generation instead
            of pseudo-random number generation (this is a standard technique in
            Monte Carlo simulations where having a near-perfect uniform
            distribution in your sample is more important than
            unpredictability). <application>GNU Backgammon</application> only
            stratifies the first 2 plies of a rollout, though it would be easy
            enough to extend it to the remainder. </para>
        </listitem>
      </orderedlist>
      <sect3 id="gnubg-rollouts_gnubg_quasi">
        <title>Quasi-Random Dice</title>
        <para>Quasi-Random Dice are used to reduce the element of luck in
        rollouts. Instead of selecting purely random dice, <application>GNU
          Backgammon</application> will ensure a uniform distribution of the
        first roll of the rollout. If 36 trials are requested, one game will
        start with 11, two games with 21, two games with 31, etc. In general, if
        n * 36 games is requested, n games will start with 11, 2*n games with 21
        etc. This is called <emphasis>rotation</emphasis> of the first roll.
        Similarly, if n*1296 trials is requested, the second roll will be
        rotated, such that n games will start with 11-11, n games with 11-21, n
        games with 21-21, etc. The third roll be also be rotated if the number
        of trials is proportional to 46656.</para>
        <para>Suppose a user stops a 1296 trial rollout after 36 games. The 36
        games would have had the following rolls for the first two rolls of each
        game: 11-11, 21-11, 12-11, 31-11, 13-11, ..., 66-11 Obviously such a
        rollout will give skewed results since the second roll was 11 for all
        games! To avoid this problem <application>GNU Backgammon</application>
        will randomize the sequence of rolls such that it is guaranteed that for
        any sample of 36 games you have exactly one game with first roll 11,
        exactly one game with second roll 11, etc. This is called
          <emphasis>stratification</emphasis>.</para>
        <para><application>GNU Backgammon</application> will actually also rotate
        and stratify rollouts where the number of trials are not multiples of
        36, 1296, etc. The distribution of rolls is obviously not uniform any
        longer in this case, but it will still provide some reduction of the
        luck, i.e., no 37 trial rollout will have 3 games with a initial 66.</para>
        <para>Before the first game of a rollout, <application>GNU
        Backgammon</application> creates a pseudo random array which it will use
        for all the games in the rollout. In effect it has already decided the
        roll sequence it will use for up to 128 rolls in every game of the
        rollout. In other words, for a normal rollout where games don't go over
        64 moves, every single game of every possible rollout length has already
        had its dice sequence determined. During the rollout of game n, sequence
        n will be used, for game n+1 sequence n+1, etc. If it's a
          <emphasis>rollout as initial position</emphasis>, then whenever the
        current sequence starts with a double, the sequence is skipped and the
        dice routine moves on to the next sequence. Say an <emphasis>rollout as
          initial position</emphasis> is about to start using sequence 275, but
        that sequence begins with a double. The dice routine moves to sequence
        276. On the following game, it will use sequence 277 (it remembers how
        many it has already skipped).</para>
        <para>So, if you select <emphasis>rollout as initial position</emphasis>
        and 36 games, then you will get a prefect set of rolls for games 1..30
        and the first 6 rolls of the next perfect set (the same rolls you would
        have gotten for games 31..36 if you'd asked for 1080 games or 10800
        games or 92 games or whatever.</para>
        <para>The dice sequence doesn't know how many trials it will be asked for,
        it simply generates sequences such that for a normal rollout
          (<emphasis>rollout as initial position</emphasis>) every 36 (30) games
        you get all possible 1st rolls, every 1296 (1080) games get every
        possible first 2 rolls, every 46656 (38880) games you get full sets of 3
        rolls, etc.</para>
      </sect3>
    </sect2>
  </sect1>
  <sect1 id="gnubg-custom">
    <title>Customizing <application>GNU Backgammon</application></title>
    <sect2 id="gnubg-custom_eval">
      <title>Evaluation settings</title>
      <sect3 id="gnubg-custom_eval_intro">
        <title>Introduction to evaluation settings</title>
        <para><application>GNU Backgammon</application> evaluation functionality
          is driven by 3 separate neural networks. The neural nets evaluates
          each position statically, and returns the outcome probabilities of the
          game at the given position. However, there are several different
          methods and techniques that an evaluation can use, and these can be
          adjusted. It's possible to set different levels of lookahead, it's
          possible to add noise to the evaluation, and each evaluation can be
          done cubeful or cubeless. All these setting together form a total
            <emphasis>evaluation setting</emphasis>. In <application>GNU
            Backgammon</application> there are several of these evaluations
          setting for each operation <application>GNU Backgammon</application>
          does.</para>
        <orderedlist continuation="restarts" inheritnum="ignore">
          <listitem>
            <para>Evaluation setting for Hints and Evaluations </para>
          </listitem>
          <listitem>
            <para>Evaluation setting for analysis. </para>
          </listitem>
          <listitem>
            <para>Evaluation setting for <application>GNU
              Backgammon</application> when it's playing. </para>
          </listitem>
          <listitem>
            <para>Several evaluation settings for each move performed in a
              rollout. </para>
          </listitem>
        </orderedlist>
      </sect3>
      <sect3 id="gnubg-custom_eval_depth">
        <title>The depth to search and plies</title>
        <para>A <emphasis>ply</emphasis> is simply considered to be one turn by
          a player. Any position can be evaluated at 0-ply. That means that GNU
          Backgammon does not look ahead in the game to evaluate the position.
          When GNU Backgammon is evaluating a checker play decision, it looks at
          all resulting positions after all the legal moves with the given dice
          roll, and evaluates these position at the given ply. It's possible to
          set the search depth by specifying the plies lookahead in any
          evaluation settings dialog.</para>
        <para>Snowie users: <application>GNU Backgammon</application> differs
          from some other software, notably Snowie in that <application>GNU
            Backgammon</application> zero ply is the same as Snowie 1 ply. In
          the same way what is called 2-ply in <application>GNU
          Backgammon</application> will therefore be similar to a Snowie 3-ply.</para>
        <para>For <application>GNU Backgammon</application>, a 0-ply evaluation
          of a move would be done by:</para>
        <para>Build a list of all legal moves. For each move, take the resulting
          board position and use the neural net to estimate the expected
          percentage of wins/gammons/backgammons/losses/gammon losses/backgammon
          losses. Rank the moves based on this evaluation.</para>
        <para>For one ply, after doing the above step, <application>GNU
            Backgammon</application> chooses the best n moves (where n is set by
          the move filters). For each one, it takes the resulting position for
          that move and goes through all 21 possible dice rolls for the
          opponent. From these results, it works out the average expectation for
          the initial move and ranks them. This is the same as Snowie 2 ply. You
          can think of it as asking "what's my best move if I also consider
          every possible dice roll and move my opponent might make?"</para>
        <para>For 2 ply (Snowie 3 ply), a similar process is done, but this
          time, not only are the opponents possible moves considered, but, for
          each of these, the player on roll's next move will be considered as
          well.</para>
        <para>For a single move, on average there are about 20 legal moves to
          consider.</para>
        <para>When doing a one ply analysis/evaluation, for the top n moves
          (from the move filter, <application>GNU Backgammon</application> needs
          to consider 21 rolls by the opponent, 20 and possible legal moves per
          roll) = 420 positions to evaluate.</para>
        <para>Every additional ply will multiply the previous number of
          evaluations by about 400 odd, which explains the huge difference in
          playing speed/analysis speed between 0 ply and 2 ply settings. I don't
          think many people would enjoy playing against <application>GNU
            Backgammon</application> at 3 ply settings, where moves could take
          minutes to be selected. It's also not clear that using much deeper
          lookahead actually gains a lot in terms of playing strength - if you
          really need better answers than 2 ply, rollouts are probably a lot
          better.</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_define">
        <title>Defining evaluation settings</title>
        <para>First of all: There are several places in <application>GNU
            Backgammon</application> where you can adjust either it's skill at
          playing or the quality of it's hints and analysis:</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_skill">
        <title>Playing skill:</title>
        <para><menuchoice><guimenu>Settings</guimenu><guimenuitem>Players</guimenuitem><guimenuitem>Player 0</guimenuitem></menuchoice> - choose Supremo or World Class. GNU Backgammon will
          take longer choosing its moves, but they will be very strong. At this
          setting, it is much stronger than Jellyfish level 7.</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_hint">
        <title>Hints:</title>
        <para><menuchoice><guimenu>Settings</guimenu><guimenuitem>Evaluation</guimenuitem></menuchoice> - choose Supremo or World Class if you want hints to be
          very accurate, but, like the playing skill setting, you may find that
          it can take as long as 15 seconds to get an answer on a 1GHz PC.
          Expert will be very fast, but for some positions where you need to
          consider what your opponent may do on his roll and how you will follow
          it up, the results will be less accurate. A wild guess would be
          somewhere around 2 or 3 percent of the time, World Class or stronger
          settings would give a different best move and maybe less than 1/2
          percent of the time, the Expert result would be seriously
        wrong.</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_analysis">
        <title>Analysis:</title>
        <para><menuchoice><guimenu>Settings</guimenu><guimenuitem>Analysis</guimenuitem></menuchoice> - these settings are used by the Analyze Move/Game/Match
          or Session command. Note that this is totally different to what is
          used in the Hint command, which uses the above settings. You probably
          want at least World Class here. My experience on a 700MHz PC is that a
          7 point match takes about 15 to 20 minutes to analyze on the Supremo
          settings. But the results tend to be very accurate.</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_rollout">
        <title>Rollouts:</title>
        <para><menuchoice><guimenu>Settings</guimenu><guimenuitem>Rollouts</guimenuitem><guimenuitem>General Settings</guimenuitem></menuchoice> tick the boxes for 'Cube decisions use same settings
          same as checker play' and 'Use same settings for both players'</para>
        <para><menuchoice><guimenu>Settings</guimenu><guimenuitem>Rollouts</guimenuitem><guimenuitem>First Play Both</guimenuitem></menuchoice> - select Expert here (this is my opinion). When doing
          rollouts, most of the time Expert play will be more than strong enough
          if you do say 1296 trials with no truncation. The rollout function has
          an enormous number of options, most of which are only useful when
          trying to investigate special positions. The simple expert setting for
          both players is probably more accurate than any of the Analysis
          functions. The downside is that rolling out 1296 trials of an early
          move in a game can take a couple of hours. On World Class or Supremo
          rollout settings, it can take more than 24 hours of computing
        time.</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_dialog">
        <title>Changing evaluation settings</title>
        <para>A typical evaluation settings dialog is shown in this figure.</para>
        <figure float="0" id="gnubg-fig_evaldialog">
          <title>The evaluation settings dialog</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/evalsetting.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>The dialog is consisting of two columns, the left column is for
          setting the checker play decision evaluation settings, and the right
          column is for setting the cube decision evaluation settings.</para>
        <para>For each column you can select some predefined settings, or you
          can define your own settings.</para>
        <para>In the lookahead box, you can adjust the lookahead of each
          evaluation by specifying the plies to be evaluated. Each ply costs
          approximately a factor of 21 in computational time. Also note that
          2-ply is equivalent to Snowie's 3-ply setting.</para>
        <para>For evaluation deeper than 0 plies, it's possible to reduce the
          number of rolls to evaluate in the lookahead. This can be set in the
          Reduced evaluation box. Instead of averaging over all 21 possible dice
          rolls it is possible to average over a reduced set, for example 7
          rolls for the 33% speed option. The 33% speed option will typically be
          three times faster than the full search without reduction.</para>
        <para>In the box for Cubeful evaluations, you can specify if you want
          GNU Backgammon to evaluate the cube ownership in it's evaluations.
          With this option turned on it generally improves the evaluation,
          specially when it's close to cube decisions, so we recommend that this
          option is turned on.</para>
        <para>In the Noise box, you can add noise to the evaluation. This can be
          smart if you think the program plays to strong. You can use the Noise
          box option to introduce noise or errors in the evaluations. This is
          useful for introducing levels below 0-ply. The lower rated bots (e.g.,
          GGotter) on the GamesGrid backgammon server uses this technique. The
          introduced noise can be deterministic, i.e., always the same noise for
          the same position, or it can be random.</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_predefined">
        <title>Predefined settings</title>
        <para>At the top of each evaluation settings column, it's possible to
          set a predefined setting.</para>
        <orderedlist continuation="restarts" inheritnum="ignore">
          <listitem>
            <para>Beginner This setting uses no lookahead and add up to 0.060
              noise to the evaluation. With this setting <application>GNU
                Backgammon</application> will evaluate like a beginner. </para>
          </listitem>
          <listitem>
            <para>Casual play This setting uses no lookahead and add up to 0.050
              noise to the evaluation. With this setting <application>GNU
                Backgammon</application> will evaluate a bit better than the
              beginner setting but not much. </para>
          </listitem>
          <listitem>
            <para>Intermediate This setting uses no lookahead and add up to
              0.030 noise to each evaluation. It still plays a intermediate
              game. </para>
          </listitem>
          <listitem>
            <para>Advanced This setting uses no lookahead and add up to 0.015
              noise to each evaluation. This setting plays a good game. </para>
          </listitem>
          <listitem>
            <para>Expert This setting uses no lookahead, but does not add any
              noise to the evaluations. This settings play a strong game.
            </para>
          </listitem>
          <listitem>
            <para>World class This setting uses 2-ply lookahead, it uses no
              noise, and it uses a normal move filter. This plays a really
              strong game close to the best humans players in the world. </para>
          </listitem>
          <listitem>
            <para>Supremo This is basically the same as the World Class setting,
              but it uses a larger move filter. </para>
          </listitem>
          <listitem>
            <para>Grandmaster This setting uses 3-ply lookahead, no noises, and
              a normal move filter. This setting is extremely strong, but it's
              also very slow. </para>
          </listitem>
        </orderedlist>
      </sect3>
      <sect3 id="gnubg-custom_eval_filter">
        <title>Move filters</title>
        <sect4 id="gnubg-custom_eval_filter_intro">
          <title>Introduction to move filters</title>
          <para><application>GNU Backgammon</application> uses a technique
            called move filters in order to prune the complete list of legal
            moves when analyzing checker play decisions. Move filters can be
            considered a generalization of the search space used in earlier
            versions of <application>GNU Backgammon</application>.</para>
          <para>A move filter for a given ply, say, 2-ply, consists of four
            parameters for each sub ply:</para>
          <orderedlist continuation="restarts" inheritnum="ignore">
            <listitem>
              <para>whether to analyze at all at this sub ply, </para>
            </listitem>
            <listitem>
              <para>the number of moves always accepted at the given level,
              </para>
            </listitem>
            <listitem>
              <para>the number of extra moves to add, </para>
            </listitem>
            <listitem>
              <para>the threshold for adding extra moves. </para>
            </listitem>
          </orderedlist>
          <para>A move filter for a given ply, say, 2-ply, consists of four
            parameters for each sub ply:</para>
          <para>whether to analyze at all at this sub ply, the number of moves
            always accepted at the given level, the number of extra moves to
            add, the threshold for adding extra moves. For example, for 2-ply
            checker play decisions there are two move filters: one for pruning
            at 0-ply, and another for pruning at 1-ply. The predefined setting
              <emphasis>Normal</emphasis> has: accept 0 moves and add up to 8
            moves within 0.16 at 0-ply, and no pruning at 1-ply.</para>
          <para>Consider the opening position where 4-2 has been rolled:</para>
          <figure float="0" id="gnubg-fig_movefilter">
            <title>Example of move filter settings</title>
            <mediaobject>
              <imageobject>
                <imagedata fileref="images/movefilterex.png"/>
              </imageobject>
            </mediaobject>
          </figure>
          <para><application>GNU Backgammon</application> starts by finding all
            possible moves and evaluate those at 0-ply:</para>
          <informaltable frame="all">
            <tgroup cols="6">
              <tbody>
                <row>
                  <entry>1.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>8/4 6/4</entry>
                  <entry>Eq.:+0.189</entry>
                  <entry></entry>
                </row>
                <row>
                  <entry>2.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/20 13/11</entry>
                  <entry>Eq.:+0.046</entry>
                  <entry>(-0.143)</entry>
                </row>
                <row>
                  <entry>3.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>13/11 13/9</entry>
                  <entry>Eq.:+0.044</entry>
                  <entry>(-0.145)</entry>
                </row>
                <row>
                  <entry>4.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/22 13/9</entry>
                  <entry>Eq.:+0.034</entry>
                  <entry>(-0.155)</entry>
                </row>
                <row>
                  <entry>5.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/22 24/20</entry>
                  <entry>Eq.:-0.006</entry>
                  <entry>(-0.194)</entry>
                </row>
                <row>
                  <entry>6.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/18</entry>
                  <entry>Eq.:-0.009</entry>
                  <entry>(-0.198)</entry>
                </row>
                <row>
                  <entry>7.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/20 6/4</entry>
                  <entry>Eq.:-0.019</entry>
                  <entry>(-0.208)</entry>
                </row>
                <row>
                  <entry>8.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>13/9 6/4</entry>
                  <entry>Eq.:-0.024</entry>
                  <entry>(-0.213)</entry>
                </row>
                <row>
                  <entry>9.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>13/7</entry>
                  <entry>Eq.:-0.052</entry>
                  <entry>(-0.241)</entry>
                </row>
                <row>
                  <entry>10.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/20 8/6</entry>
                  <entry>Eq.:-0.053</entry>
                  <entry>(-0.242)</entry>
                </row>
              </tbody>
            </tgroup>
          </informaltable>
          <para/>
          <para>According to the move filter the first 0 moves are accepted. The
            equity of the best move is +0.189, and according to the move filter
            we add up to 8 extra moves if they're within 0.160, that is, if they
            have equity higher than 0.029. Moves 5 through 18 all have equity
            lower that, so the move list after pruning at 0-ply consists of
            moves 1 through 4. According to the move filter we do not perform
            any pruning at 1-ply, so moves 1 through 4 are submitted for
            evaluation at 2-ply;</para>
          <informaltable frame="all">
            <tgroup cols="6">
              <tbody>
                <row>
                  <entry>1.</entry>
                  <entry>Cubeful</entry>
                  <entry>2-ply</entry>
                  <entry>8/4 6/4</entry>
                  <entry>Eq.:+0.180</entry>
                  <entry></entry>
                </row>
                <row>
                  <entry>2.</entry>
                  <entry>Cubeful</entry>
                  <entry>2-ply</entry>
                  <entry>24/20 13/11</entry>
                  <entry>Eq.:+0.052</entry>
                  <entry>(-0.127)</entry>
                </row>
                <row>
                  <entry>3.</entry>
                  <entry>Cubeful</entry>
                  <entry>2-ply</entry>
                  <entry>13/11 13/9</entry>
                  <entry>Eq.:+0.043</entry>
                  <entry>(-0.137)</entry>
                </row>
                <row>
                  <entry>4.</entry>
                  <entry>Cubeful</entry>
                  <entry>2-ply</entry>
                  <entry>24/22 13/9</entry>
                  <entry>Eq.:+0.035</entry>
                  <entry>(-0.145)</entry>
                </row>
                <row>
                  <entry>5.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/22 24/20</entry>
                  <entry>Eq.:-0.006</entry>
                  <entry>(-0.185)</entry>
                </row>
                <row>
                  <entry>6.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/18</entry>
                  <entry>Eq.:-0.009</entry>
                  <entry>(-0.189)</entry>
                </row>
                <row>
                  <entry>7.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/20 6/4</entry>
                  <entry>Eq.:-0.019</entry>
                  <entry>(-0.199)</entry>
                </row>
                <row>
                  <entry>8.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>13/9 6/4</entry>
                  <entry>Eq.:-0.024</entry>
                  <entry>(-0.203)</entry>
                </row>
                <row>
                  <entry>9.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>13/7</entry>
                  <entry>Eq.:-0.052</entry>
                  <entry>(-0.232)</entry>
                </row>
                <row>
                  <entry>10.</entry>
                  <entry>Cubeful</entry>
                  <entry>0-ply</entry>
                  <entry>24/20 8/6</entry>
                  <entry>Eq.:-0.053</entry>
                  <entry>(-0.232)</entry>
                </row>
              </tbody>
            </tgroup>
          </informaltable>
          <para/>
          <para>If we instead request a 4-ply checker play decision,
              <application>GNU Backgammon</application> will use the move
            filters defined for 4-ply:</para>
          <informaltable frame="all">
            <tgroup cols="4">
              <colspec colname="c1" colnum="1" colwidth="1*"/>
              <colspec colname="c2" colnum="2" colwidth="1*"/>
              <colspec colname="c3" colnum="3" colwidth="1*"/>
              <colspec colname="c4" colnum="4" colwidth="1*"/>
              <tbody>
                <row>
                  <entry>Ply</entry>
                  <entry>Accept moves</entry>
                  <entry>Extra moves</entry>
                  <entry>Threshold for extra moves</entry>
                </row>
                <row>
                  <entry>0</entry>
                  <entry>0</entry>
                  <entry>8</entry>
                  <entry>0.160</entry>
                </row>
                <row>
                  <entry>1</entry>
                  <entry>no pruning</entry>
                  <entry> </entry>
<entry> </entry>
</row>
                <row>
                  <entry>2</entry>
                  <entry>0</entry>
                  <entry>2</entry>
                  <entry>0.040</entry>
                </row>
                <row>
                  <entry>3</entry>
                  <entry>no pruning</entry>
                  <entry> </entry>
<entry> </entry>
</row>
              </tbody>
            </tgroup>
          </informaltable>
          <para>The 4-ply move filter is identical to the 2-ply for pruning at
            0-ply, so after 0-ply we have the same three moves as above. Since
            there is no pruning at 1-ply these three moves are evaluated at
            2-ply as above. There is no pruning at 3-ply.</para>
          <para>At 4-ply we do not accept any moves, but add up to two moves if
            there within 0.040 from the best move. Since the second best move is
            -0.138 worse than the best move, we do not accept any moves to be
            evaluated at 4-ply. Hence <application>GNU Backgammon</application>
            will actually not evaluate any moves on 4-ply.</para>
          <para>The predefined move filters all have accept 0 moves, in order to
            facilitate fast decisions and analysis, i.e., no need to waste much
            time over obvious moves.</para>
          <para>For post-mortem analysis it may be worthwhile to ensure that GNU
            Backgammon analyzes at least two moves at the specified ply. To do
            this, specify accept 2 moves in the move filters you use for
            analysis. However, do note that <application>GNU
            Backgammon</application> will force evaluation at the specified ply
            if the actual move made is doubtful. This ensures that all errors
            and blunders are evaluated at the same level.</para>
        </sect4>
        <sect4 id="gnubg-custom_eval_filter_define">
          <title>Defining move filters</title>
          <para>The move filter allows you to control exactly how many moves GNU
            is examining at each ply. A ply is basically one move played by one
            side, thus if both sides played a move, it would be one whole move,
            but two plies, one for each side. To change the specific settings,
            press the Modify... button.</para>
          <para>Although the predefined levels, such as World Class, Supremo,
            etc. are tested and good, you may want to know or control how GNU
            filters its moves to analyze and how many.</para>
          <figure float="0" id="gnubg-fig_movefilter1">
            <title>Move filter 1</title>
            <mediaobject>
              <imageobject>
                <imagedata fileref="images/movefilter1.png"/>
              </imageobject>
            </mediaobject>
          </figure>
          <para>If you are playing Expert level (this is what GGRaccoon is set
            at) or another 0-ply setting, the Move Filter settings will not
            change a thing, as Expert level automatically examines all moves. At
            Supremo level, this changes though, as it takes a selection of the
            best moves from 0-ply and examines them at 2-ply. This means that
            for those selected moves it will calculate all the possibilities 2
            plies ahead and evaluate them, allowing it to find better moves.
            Since Supremo is a 2-ply setting, we are only interested in the
            2-ply settings of Large as in the figure above. 3-ply or 4-ply
            settings will have no effect here because Supremo doesn't examine at
            that depth.</para>
          <para>In the figure above, we can see it first will Always accept 0
            moves. This first line means that it won't force any moves to be
            analyzed at 2-ply, it will only analyze moves according to the
            second line. If it had said it would always analyze 2 moves, this
            would mean that no matter how ridiculously bad the 2nd move was
            compared to the 1st, it would analyze both at 2-ply.</para>
          <para>The second line says it will Add extra 16 moves within 0.320.
            This means that provided they aren't more than 0.320 equity worse
            than the top move, it will select a maximum of 16 moves to analyze
            at 2-ply. For example, in the figure below, the 2nd best move is no
            less than 0.453 equity worse than the top choice, so it didn't
            bother analyzing them at 2-ply as it is unlikely to change its mind
            on what the best move is.</para>
          <figure float="0" id="gnubg-fig_movefilter2">
            <title>Move filter 2</title>
            <mediaobject>
              <imageobject>
                <imagedata fileref="images/movefilter2.png"/>
              </imageobject>
            </mediaobject>
          </figure>
          <para>Take a look at next figure.</para>
          <figure float="0" id="gnubg-fig_movefilter3">
            <title>Move filter 3</title>
            <mediaobject>
              <imageobject>
                <imagedata fileref="images/movefilter3.png"/>
              </imageobject>
            </mediaobject>
          </figure>
          <para>Here, the exact same settings were maintained, but the 1-ply
            filter was activated. This just means that those 16 moves selected
            from the 0-ply are sent instead to be analyzed at 1-ply, and then up
            to 5 moves from 1-ply will be sent to be analyzed at 2-ply. So this
            would actually be faster than the previous setting (and weaker),
            since a maximum of only 5 moves would be analyzed at 2-ply depth.</para>
          <para>Tip: Feel free to experiment with the settings, as you can
            always reset them by simply choosing one of the predefined levels.
            In order to see if they are better, or as good but faster, I'd
            suggest comparing the results with Supremo. One setting I have that
            works quite well, is to take the basic Supremo setting and in the
            Move filter reduce the 16 to 12. It cuts down on the thinking time
            by 20-25% more or less, and I haven't seen more than one case in
            over 10,000 moves where it missed the best move.</para>
        </sect4>
      </sect3>
      <sect3 id="gnubg-eval_cubeful">
        <title>Cubeful vs. Cubeless</title>
        <para>In the evaluation settings dialog box you can specify whether or
          not checker play should be evaluated cubeful. It's recommended that
          you use cubeful evaluation. To get an understanding of what cubeful
          checker play evaluations are, you can take a look at this position:</para>
        <figure float="0" id="gnubg-fig_cubeful">
          <title>Cubeful example</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/cubeful-ex1.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>In this position black has rolled 51 and he has a good position.
          If the position is evaluated cubeless the best move is 13/7. Black can
          hope white does not roll 34 or 35 form the bar and has now a good
          chance to close white out in the next few rolls. However if white
          rolls one of the four hitting numbers from the bar, white will quite
          soon have a really hot redouble. This redouble increases whites equity
          so much that black actually should play this move safe. He should play
          13/8 6/5. However if the evaluation was set to cubeless, an setting
          which assumes white will never redouble, black should play 13/8.</para>
        <para>Here's another example:</para>
        <figure float="0" id="gnubg-fig_cubeful2">
          <title>Cubeful example 2</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/cubeful-ex2.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>This is from a 5 point match where black has 1 point and white has
          3 points. Black wins the opening roll and considers playing 13/11 6/5
          or 24/23 13/11.</para>
        <para>If <application>GNU Backgammon</application> uses a cubeless
          evaluation it will play 24/23 13/11. But if you're using a cubeful
          evaluation it will play 13/11 6/5. Slotting with 6/5 is at this score
          a better move even though it loses more gammons. The gammons black are
          losing won't matter anyway, since black will turn the cube in the next
          few rolls anyway. The slotting play also wins more gammons, and with
          the cube tuned to 2, black should play towards gammonish positions at
          this score.</para>
        <para>You can read more about cubeful evaluations in the [[Appendix]].</para>
        <para>It's recommended that you use cubeful checker evaluations.</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_reduced">
        <title>Reduced evaluations</title>
        <para>This option is designed to increase the speed of play by taking a
          shortcut. Instead of averaging over all 21 possible dice rolls, it is
          possible to average over a reduced set, such as only 7 rolls which
          would be 1/3 or 33%. The 33% speed option should be approximately 3
          times faster than the full search with no reduction. One point, it has
          been noted that this can badly hurt <application>GNU
          Backgammon</application>'s checker play so it is not advised to use it
          here.</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_pruning">
        <title>Pruning neural networks</title>
        <para>A new feature in the evaluation is the use of a set of neural
          networks just to prune away move candidates within a deeper ply
          search. This increases the speed considerably and it doesn't lose much
          playing strength compared to evaluation without these pruning neural
          nets. Jim Segrave has just done an analysis of this and found that
          less than 1% of all moves come out different with the pruning nets
          activated. In most of these positions the move would not have made any
          difference to the game at all.</para>
        <para>Notice, You can not use both reduced evaluations and pruning
          neural nets.</para>
      </sect3>
      <sect3 id="gnubg-custom_eval_noise">
        <title>Noise</title>
        <para>If you think <application>GNU Backgammon</application> plays too
          strong for you, you can add some noise to its evaluation. The number
          you add into the field in the evaluations setting is the limit amount
          of noise that will be added to the evaluation.</para>
        <para>If noise is added to the evaluations <application>GNU
          Backgammon</application> will take a Box Müller transform of a point
          in the unit circle and add to each possible outcome probability. This
          means that the addition is random, but distributed so that it's more
          likely to have an noise addition close to zero than a noise addition
          close to the limit. The noise addition is limited to the number you
          put into the noise field in the dialog box.</para>
        <para>If you check the box Deterministic noise, the noise added to each
          evaluation will be based on a sum of the bytes in the hash of the
          board position, which (by the central limit theorem) should have a
          normal distribution. In that way you will always have that same noise
          amount to a position, since the noise added to the evaluation is only
          depending on the position itself.</para>
        <para>If you want <application>GNU Backgammon</application> to evaluate
          and play as strong as possible, you should not add any noise.</para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-custom_appearance">
      <title>Appearance</title>
      <para>You can change the appearance of <application>GNU
        Backgammon</application>. There is a lot of options to choose among and
        you can have the board look like nearly anything. This section will help
        you through some on the appearance customization.</para>
      <para>To change the look of the board, you should click <menuchoice><guimenu>Settings</guimenu><guimenuitem>Appearance</guimenuitem></menuchoice>. This will open a dialog box like this:</para>
      <figure float="0" id="gnubg-fig_appear">
        <title>The appearance dialog</title>
        <mediaobject>
          <imageobject>
            <imagedata fileref="images/appearence.png"/>
          </imageobject>
        </mediaobject>
      </figure>
      <para>In this dialog box you see a preview picture of the board at the
        right side, and you have notebook with options to the left.</para>
      <para>There are two different board rendering engines in <application>GNU
          Backgammon</application>. It's a 2 dimensional rendering engine which
        is simple and fast, but still makes really good board images. The moves
        can be animated.</para>
      <para>The other board rendering type is a 3 dimensional board engine based
        on OpenGL. This board rendering engine makes astonishing fine board
        graphics, and animates the rolls and moves beautifully. You can even add
        textures to your boards and checkers. However, the 3D rendering type
        need a good modern graphic card which can take 3D hardware acceleration.</para>
      <para>The leftmost tab in the appearance settings notebook is the General
        option. You can here select between the 2D board or the 3D board. You
        can also choose between different other settings. Most of the settings
        here are self explanatory.</para>
      <warning>
        <para>Don't forget to save your settings!! A lovely and painstakingly
          crafted board setup can be lost if you don't faithfully do your <menuchoice><guimenu>Settings</guimenu><guimenuitem>Save settings</guimenuitem></menuchoice>.</para>
      </warning>
    </sect2>
  </sect1>
  <sect1 id="gnubg-technotes">
    <title>Technical Notes</title>
    <sect2 id="gnubg-tech_databases">
      <title>Obtaining bearoff databases</title>
      <sect3 id="gnubg-tech_databases_generate">
        <title>Generate your own</title>
        <para><application>GNU Backgammon</application> is supplied with a
          program makebearoff that is used to generate bearoff databases. Due to
          various limitations it is only possible to generate bearoff databases
          with a size less than 2GB, i.e., the 13pt one-sided database and the
          11 checker two-sided database are the largest databases that can be
          generated with makebearoff. </para>
        <para>To generate one sided database issue </para>
        <para>makebearoff -o 10 -f gnubg_os.bd</para>
        <para>to generate the one sided 10 point database. The program
          makebearoff uses a cache to store previously generated positions. You
          may set the cache size with the -s size option, e.g., </para>
        <para>makebearoff -o 10 -s 123456789 -f gnubg_os.bd</para>
        <para>to use 123,456,789 bytes of memory for cache size. In general, if
          the cache size is less than the size of the database to be generated,
          then extra time is needed to generate the bearoff database because
          some positions may have to be calculated several times. </para>
        <para>makebearoff can also reuse previously generated databases, so if
          you already had generated the 9 point database you can reuse it: </para>
        <para>mv gnubg_os.bd gnubg_os9.bd</para>
        <para>makebearoff -o 10 -O gnubg_os9.bd -f gnubg_os.bd</para>
        <para>Note that makebearoff requires temporary disk space to generate
          both one sided and two sided databases. In general, twice the disk
          space of the database to be generated is needed. </para>
        <para>To generate a two sided database issue </para>
        <para>makebearoff -t 6x8 -f gnubg_ts.bd</para>
        <para>This example will generate the 8 checkers on 6 points database.
          Again, it's possible to adjust the amount of memory with the -s
          option. It's recommended to set the cache size to the maximum amount
          of memory available (although there is no need to set it beyond the
          size of the bearoff database to be generated). </para>
        <para>Other options for makebearoff are available, see makebearoff
          --help for the complete set. </para>
        <para>At compile time the built-in one sided bearoff database is
          generated with the command </para>
        <para>makebearoff -o 6 | makebearoff1 -o br1.c</para>
        <para>which generated a 6 point one sided bearoff database. The database
          is piped into makebearoff1 that generates the C code for the database.
          The resulting br1.c is more than 8MB, so it's not distributed with the
          source for <application>GNU Backgammon</application>. </para>
        <para>The accompanying program makehyper is used to generate databases
          for Hypergammon. For example, to generate the 3-checker database issue
          the command </para>
        <para>makehyper -c 3 -f hyper3.bd</para>
        <para>Since the generation is <emphasis>very</emphasis> time consuming
          makehyper will generate a checkpoint file (in the example above:
          hyper1.bd.tmp) that can be used to restart the calculation if needed
          by using the -r option. You can also change the default convergence
          threshold of 0.00001 if you're happy with less accurate equities. To
          generate the 3 checker database you need approximately 400 MB of free
          memory. On a 2.4 GHz box with 512 MB of RAM the calculation ran for 58
          iterations of 3000 seconds each, i.e., a total of 48 hours! </para>
        <para>See makehyper --help for the complete set of available options.
        </para>
      </sect3>
      <sect3 id="gnubg-tech_databases_download">
        <title>Download</title>
        <para>You may download the two sided database with 6 checkers on 6
          points from <ulink url="ftp://alpha.gnu.org/gnu/gnubg/gnubg_ts0.bd.gz">ftp://alpha.gnu.org/gnu/gnubg/gnubg_ts0.bd.gz</ulink> and the one
          sided database with 15 checkers 6 points from <ulink url="ftp://alpha.gnu.org/gnu/gnubg/gnubg_os0.bd.gz">ftp://alpha.gnu.org/gnu/gnubg/gnubg_os0.bd.gz</ulink>. </para>
        <para>Later, other databases may be available for download or it may be
          possible to purchase these on CDROM or DVD for a nominal fee. </para>
      </sect3>
      <sect3 id="gnubg-tech_databases_verify">
        <title>Verification of databases</title>
        <para>To verify that your generated or downloaded bearoff database is
          correct, the table below lists the MD5 checksums for a number of
          possible databases. </para>
      </sect3>
      <sect3 id="gnubg-tech_databases_os">
        <title>One-sided bearoff databases (compressed)</title>
        <para>The table below contains the MD5 checksums for the compressed one
          sided bearoff databases, i.e., databases generated with default
          options. </para>
        <informaltable frame="all">
          <tgroup cols="3">
            <tbody>
              <row>
                <entry>Checkers </entry>
                <entry>Points </entry>
                <entry>MD5 checksum </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>1 </entry>
                <entry>c789f049ec98ce4e307b471257999f39 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>2 </entry>
                <entry>b6e61c1625ae4b3b164e93ab064192b9 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>3 </entry>
                <entry>346dae6139ccb4b227c534373e5c52e4 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>4 </entry>
                <entry>653255f5f9f22fd50277f7ff25b2a343 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>5 </entry>
                <entry>2064f9a56b23117d053a573c96a92fa2 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>6 </entry>
                <entry>3dc7b833c4670849cee00479a9e21b49 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>7 </entry>
                <entry>67235c8e0ee152df5daf36cbeae5b3c2 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>8 </entry>
                <entry>a4acbb5c7e9e1f08e561afe0af934e5c </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>9 </entry>
                <entry>9c4ddab4e51c3e668c9c97b8f8768dbc </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>10 </entry>
                <entry>81b3898f06bbd08ee8295a839251a10a </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>11 </entry>
                <entry>78ecb4be86dab6af8755ea4063d50fb6 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>12 </entry>
                <entry>770fcff48894a96ebb2249343ef94866 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>13 </entry>
                <entry>cc74b69a62f6e648936f533838a527a8 </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>14 </entry>
                <entry>not available </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>15 </entry>
                <entry>not available </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>16 </entry>
                <entry>not available </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>17 </entry>
                <entry>not available </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>18 </entry>
                <entry>not available </entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
      </sect3>
      <sect3 id="gnubg-tech_databases_ts">
        <title>Two-sided bearoff databases (with cubeless and cubeful equities)</title>
        <para>The table below contains the MD5 checksums for the default two
          sided bearoff databases. </para>
        <informaltable frame="all">
          <tgroup cols="3">
            <tbody>
              <row>
                <entry>Checkers </entry>
                <entry>Points </entry>
                <entry>MD5 checksum </entry>
              </row>
              <row>
                <entry>1 </entry>
                <entry>6 </entry>
                <entry>7ed6f8e7fce16ea2b80e07a4a516653c </entry>
              </row>
              <row>
                <entry>2 </entry>
                <entry>6 </entry>
                <entry>e9d760bf213841c285245ed757a52f4d </entry>
              </row>
              <row>
                <entry>3 </entry>
                <entry>6 </entry>
                <entry>9d67da3db32ad4720cc38eecf9a67967 </entry>
              </row>
              <row>
                <entry>4 </entry>
                <entry>6 </entry>
                <entry>9156f37032d1d4b0352a41186e632dfc </entry>
              </row>
              <row>
                <entry>5 </entry>
                <entry>6 </entry>
                <entry>0db19ab08feae1feb33ddbd709479f62 </entry>
              </row>
              <row>
                <entry>6 </entry>
                <entry>6 </entry>
                <entry>44b6040b49b46cb9dd2ce8caa947044d </entry>
              </row>
              <row>
                <entry>7 </entry>
                <entry>6 </entry>
                <entry>9eb8b042d4d2ddf8d40e74a892745ad5 </entry>
              </row>
              <row>
                <entry>8 </entry>
                <entry>6 </entry>
                <entry>fcdbbc80b7ef84ddc81b839d0f26bed1 </entry>
              </row>
              <row>
                <entry>9 </entry>
                <entry>6 </entry>
                <entry>a11b2d410d51401143d05e73f9ffac15 </entry>
              </row>
              <row>
                <entry>10 </entry>
                <entry>6 </entry>
                <entry>12dc70c86f356d06bc96ee38dee40c62 </entry>
              </row>
              <row>
                <entry>11 </entry>
                <entry>6 </entry>
                <entry>not available </entry>
              </row>
              <row>
                <entry>12 </entry>
                <entry>6 </entry>
                <entry>not available </entry>
              </row>
              <row>
                <entry>13 </entry>
                <entry>6 </entry>
                <entry>not available </entry>
              </row>
              <row>
                <entry>14 </entry>
                <entry>6 </entry>
                <entry>not available </entry>
              </row>
              <row>
                <entry>15 </entry>
                <entry>6 </entry>
                <entry>not available </entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
      </sect3>
      <sect3 id="gnubg-tech_databases_hyper">
        <title>Two-sided databases for Hypergammon</title>
        <para>As the generation of the Hypergammon databases are an iterative
          process it's not possible to give MD5 checksum for these, as it depend
          heavily on your convergence threshold, the number of restarts, and
          rounding errors. </para>
        <para>Below is a random position from the database. The equities and
          percentages in your own database should be very similar (if not
          identical): </para>
        <para><application>GNU Backgammon</application> Position ID:
          ADAAAQAkIAAAAA</para>
  <programlisting>
 GNU Backgammon  Position ID: ADAAAQAkIAAAAA
                 Match ID   : cAkAAAAAAAAA
 +13-14-15-16-17-18------19-20-21-22-23-24-+     O: gnubg
 |       X     X    |   |                X |     0 points
 |                  |   |                  |
 |                  |   |                  |
 |                  |   |                  |
 |                  |   |                  |
v|                  |BAR|                  |     (Cube: 1)
 |                  |   |                  |
 |                  |   |                  |
 |                  |   |                  |
 | O                |   |                  |     On roll
 | O                |   |             O    |     0 points
 +12-11-10--9--8--7-------6--5--4--3--2--1-+     X: jth

             Player       Opponent
Position         3018          2831

Owned cube                    : -0.0230
Centered cube                 : -0.2310
Centered cube (Jacoby rule)   : -0.2186
Opponent owns cube            : -0.3548

        Win     W(g)    W(bg)   L(g)    L(bg)   Equity  (cubeful)
static: 0.456   0.244   0.014   0.318   0.019   (-0.168  (-0.219))


No double           : -0.219
Double, pass        : +1.000   (+1.219)
Double, take        : -0.710   (-0.491)

Correct cube action: No double, beaver
</programlisting>
      </sect3>
    </sect2>
    <sect2 id="gnubg-tech_met">
      <title>Match Equity Tables</title>
      <para>It's possible to use several different match equity tables with GNU
        Backgammon.</para>
    </sect2>
    <sect2 id="gnubg-tech_python">
      <title>Python scripting</title>
      <para>Accessing the <application>GNU Backgammon</application> Python shell</para>
      <para>To access the Python shell, either type `&gt;' from the command
        line or select <menuchoice><guimenu>Window</guimenu><guimenuitem>Python Shell(IDLE...)</guimenuitem></menuchoice> from the GUI. </para>
      <sect3 id="gnubg-tech_python_module">
        <title>gnubg module functions</title>
        <para>board()</para>
        <para>command(cmd)</para>
        <para>evaluate()</para>
        <para>evalcontext()</para>
        <para>eq2mwc()</para>
        <para>mwc2eq()</para>
        <para>cubeinfo()</para>
        <para>met()</para>
        <para>positionid()</para>
        <para>positionfromid()</para>
        <para>positionkey()</para>
        <para>positionfromkey()</para>
        <para>positionbearoff()</para>
        <para>positionfrombearoff()</para>
        <para>navigate([next=N,[game=N]])</para>
        <para>Match navigation. </para>
        <para>Without any arguments, go to first move of first match. </para>
        <para>With next == N, move forward N game records. </para>
        <para>With game == N, move forward/backward N games. </para>
        <para>Navigate never wraps around. </para>
        <para>On success, returns None. If unable to complete the requested
          number of moves, returns a pair of (next-remaining,game-remaining). </para>
        <para>match([analysis=1/0, boards=1/0, statistics=0/1, verbose=0/1])</para>
        <para>Return the current match. For example, </para>
        <para>&gt; m = gnubg.match()</para>
        <para>Takes the following optional keyword arguments: </para>
        <para>analysis</para>
        <para>When 0, discard analysis data. default is 1. </para>
        <para>boards</para>
        <para>When 1, add current board to move/double records. Default is 1. </para>
        <para>statistics</para>
        <para>When 1, include game and match statistics. Default is 0. </para>
        <para>verbose</para>
        <para>When 1, include derived analysis values. Default is 0. </para>
      </sect3>
      <sect3 id="gnubg-tech_python_match">
        <title>Match description</title>
        <para>gnubg.match() returns a dictionary containing the following items: </para>
        <para>match-info</para>
        <para>General match info </para>
        <para>games</para>
        <para>A sequence, one element per game.</para>
        <para>stats (optional)</para>
        <para>Match statistics. </para>
      </sect3>
      <sect3 id="gnubg-tech_python_matchinfo">
        <title>Match info</title>
        <para>A dictionary containing the following items: </para>
        <para>match-length </para>
        <para>variation</para>
        <para>One of Standard,Nackgammon, Hypergammon1, Hypergammon2 or
          Hypergammon3. </para>
        <para>rules (optional)</para>
        <para>Additional rules used. A subset of NoCube, Crawford and Jacoby. </para>
        <para>X</para>
        <para>O</para>
        <para>Per player information. Each a dictionary containing rating and
          name. </para>
        <para>annotator (optional)</para>
        <para>round (optional)</para>
        <para>place (optional)</para>
        <para>date (optional)</para>
        <para>Sequence of (Day,Month,Year). </para>
        <para>event (optional)</para>
        <para>default-eval-context</para>
        <para>Default evaluation context. A dictionary in the same format as
          returned by evalcontext(). </para>
        <para>default-rollout-context</para>
        <para>Default rollout context. </para>
        <para>Example, </para>
        <para>&gt;&gt;&gt; m['match-info']</para>
        <para>{'match-length': 25, 'rules': ('Crawford',),
          'default-eval-context': {'plies': 2, 'deterministic': 1, 'reduced': 0,
          'noise': 0.0, 'cubeful': 1}, 'annotator': 'GNU 0.14', 'O': {'rating':
          '0 (Exp 0)', 'name': 'Moshe Tissona'}, 'round': 'Final', 'place':
          'Monte Carlo', 'variation': 'Standard', 'default-rollout-context':
          {'n-truncation': 11, 'initial-position': 0, 'trials': 0,
          'stop-on-std': 0, 'variance-reduction': 1, 'late-eval': 0,
          'truncated-rollouts': 0, 'truncate-bearoff2': 1, 'cubeful': 1,
          'truncate-bearoffOS': 1, 'seed': 1177750272, 'quasi-random-dice': 1,
          'minimum-games': 144}, 'date': (13, 7, 2003), 'X': {'rating': '0 (Exp
          0)', 'name': 'Jon Royset'}, 'event': 'World Championship 2003'}</para>
      </sect3>
      <sect3 id="gnubg-tech_python_game">
        <title>Python game</title>
        <para>A dictionary containing the following items: </para>
        <para>info</para>
        <para>General game info. For example, </para>
        <para>&gt;&gt;&gt; m['games'][0]['info']</para>
        <para>{'points-won': 1, 'score-X': 0, 'score-O': 0, 'winner': 'X',
          'resigned': False}</para>
        <para>If no winner is specified, winner is None. </para>
        <para>&gt;&gt;&gt; m['games'][2]['info']</para>
        <para>{'score-X': 2, 'winner': None, 'score-O': 0}</para>
        <para>game</para>
        <para>A Sequence of actions.</para>
        <para>stats (optional)</para>
        <para>Game statistics. Similar entries to <menuchoice><guimenu>Analyze</guimenu><guimenuitem>Game statistics</guimenuitem></menuchoice> from the GUI. </para>
      </sect3>
      <sect3 id="gnubg-tech_python_gameaction">
        <title>Game actions</title>
        <para>Each action is a dictionary </para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-tech_guile">
      <title>Guile scripting</title>
      <para>Earlier versions of <application>GNU Backgammon</application> had
        support for guile scripting, which, however, was unused and
        un-maintained and therefore removed.</para>
    </sect2>
    <sect2 id="gnubg-tech_equities">
      <title>Equities explained</title>
      <sect3 id="gnubg-tech_equities_intro">
        <title>Introduction to equities</title>
        <para><application>GNU Backgammon</application> works with many
          different kinds of equities. The equity is defined as the expected
          value of the position. However, this value can be expressed in several
          different metrics and may be calculated with or without taking the
          effect of the cube into consideration. In the following section we
          will describe the equities used and calculated by GNU
        Backgammon.</para>
      </sect3>
      <sect3 id="gnubg-tech_equities_money">
        <title>Money equity</title>
        <para>This is the value of the position in money game, e.g., if your
          equity is +0.4 an you are playing money game with a $1 stake, you will
          win $0.40 on average. The money equity can be calculated with or
          without taking the effect of the double cube into consideration, or
            <emphasis>cubeful</emphasis> or <emphasis>cubeless</emphasis>. The
          cubeless equity can be calculated from the basic formula:
          2*p(w)-1+2(p(wg)-p(lg))+3(p(wbg)-p(lbg)). Evaluating the cubeful
          equity is much more difficult; it can either be estimated from the
          cubeless equity by using transformations as outlined by Rick Janowski
          or by constructing a neural net that directly outputs cubeful
          equities. GNU Backgammon uses the former approach (see chapter <ulink url="http://www.gnubg.org/documentation/doku.php?id=appendix#7">Cubeful equities</ulink>).</para>
      </sect3>
      <sect3 id="gnubg-tech_equities_match">
        <title>Match Winning Chance</title>
        <para>In match play we're generally not particular interested in the
          outcome of the individual games as much as the outcome of the entire
          match, so the interesting quantity for match play is <emphasis>match
            winning chance</emphasis> (MWC). As for the money equity the MWC can
          be calculated with and without the effect of the double cube. The MWCs
          are generally calculated with the use of a match equity table, which
          contains the chance of winning the match before a game starts, e.g.,
          if the score is 0-0 in a 1pt match each player has 50% chance of
          winning the match before the game starts assuming they're of equal
          skill.</para>
        <para>The cubeless MWC is calculated as: MWC(cubeless) = p(w) * MWC(w) +
          p(l) * MWC(l) + p(wg) * MWC(wg) + p(lg) * MWC(lg) + p(wbg) * MWC(wbg)
          * p(lbg) * MWC(lbg).</para>
        <para>For example, if the w/g/bg distribution is 0 30 60 - 40 10 0 and
          the match score is 1-3 to 5 with the cube on 2 the cubeless MWC is:</para>
        <para>MWC(cubeless)= 30% * 50% + 30% * 0% + 30% * 100% + 10% * 0% + 0% *
          100% + 0% * 0% = 45%,</para>
        <para>so the cubeless MWC is 45%.</para>
        <para>Evaluating the cubeful MWC is more difficult, and as for the
          cubeful money equity it's possible to estimate cubeful MWCs from
          transformation on the w/g/bg distribution or directly calculate it
          from neural nets. GNU Backgammon uses the former approach, but the
          formula are currently not published.</para>
      </sect3>
      <sect3 id="gnubg-tech_eq_norm">
        <title>Normalized equity</title>
        <para>It's generally very difficult to compare MWCs. For example, it's
          hardly worth mentioning a 0.5% MWC error at DMP where as it's a huge
          error at 0-0 to 7. It is therefore of interesting to normalize the
          MWCs to some common scale. The most often used normalization is
          Normalized Money Game Equity (NEMG) where the MWC for any game is
          transformed into the same interval as money game, i.e., -3 to +3 (due
          to anomalies at certain match scores the NEMG can go below -3 and
          above +3). The transformation is linear:</para>
        <para>NEMG = 2 * (MWC-MWC(l))/(MWC(w)-MWC(l)) - 1</para>
        <para>In other words, extrapolation with the following two extrapolation
          points: (MWC(w),+1) and (MWC(l),-1).</para>
        <para>For example, suppose the score is 3-1 to 5 with the cube on 2:
          MWC(l)=0% and MWC(w)=50%:</para>
        <informaltable frame="all">
          <tgroup cols="3">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <colspec colname="c3" colnum="3" colwidth="1*"/>
            <tbody>
              <row>
                <entry>MWC</entry>
                <entry>NEMG</entry>
              </row>
              <row>
                <entry>0%</entry>
                <entry>-1</entry>
              </row>
              <row>
                <entry>25%</entry>
                <entry>0</entry>
              </row>
              <row>
                <entry>50%</entry>
                <entry>+1</entry>
              </row>
              <row>
                <entry>75%</entry>
                <entry>+2</entry>
              </row>
              <row>
                <entry>100%</entry>
                <entry>+3</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <para>Note that a w/g/bg distribution of 0 100 100 - 0 0 0 gives a NEMG
          of +3 whereas the corresponding money equity is only +2. This is
          because the gammon price is high for that particular score. When both
          players are far from winning the match, e.g., 0-0 to 17 or 1-0 to 17,
          NEMG is very close to the usual money equity.</para>
        <para>NEMG can be calculated from both cubeless and cubeful MWCs.</para>
        <para>A word of caution: A cubeless NEMG calculated from a cubeless MWC
          could be named <emphasis>cubeless equity</emphasis>, but in most
          backgammon literature this term seems to be reserved for the cubeless
          money equity.</para>
      </sect3>
      <sect3 id="gnubg-tech_equities_cubeful">
        <title>Cubeful equities</title>
        <para>This chapter is a brief description of how <application>GNU
            Backgammon</application> calculates cubeful equities. The formula
          build directly on the work by Rick Janowski <ulink url="http://www.msoworld.com/mindzine/news/classic/bg/cubeformulae.html">Take-Points in Money Games</ulink> from 1993.</para>
      <sect4 id="gnubg-tech_equities_cubeful_basic">
        <title>Basic formula for cubeful equities</title>
        <para>The basic formula for cubeful equities as derived by Janowski is</para>
        <para>E(cubeful) = E(dead) * (1-x) + E(live) * x,</para>
        <para>where E(dead) is the dead cube equity (cubeless equity) calculated
          from the standard formula. E(live) is the cubeful equity assuming a
          fully live cube. We'll return to that in the next section. x is the
          cube efficiency. x=0 gives E(cubeful)=E(dead) as one extreme and x=1
          gives E(cubeful)=E(live) as the other extreme. In reality x is
          somewhere in between, which typical values around 0.6 - 0.8.</para>
        <para>Janowski's article doesn't mention cubeful equities, so we use the
          straightforward generalization</para>
        <para>MWC(cubeful) = MWC(dead) * (1-x) + MWC(live) * x.</para>
        <para>as MWC is the entity that is used for match play
        evaluations.</para>
      </sect4>
      <sect4 id="gnubg-tech_equities_cubeful_live">
        <title>Live cube equities</title>
        <para>The live cube equity is the equity assuming that the equity
          changes continuously, so that doubles and takes occurs exactly at the
          double point and take point. For gammon-free play this is the
          well-known take point of 20%. Janowski derives the more general
          formula</para>
        <para>TP = (L-0.5)/(W+L+0.5)</para>
        <para>where W is the average cubeless value of games ultimately won, and
          L is the average cubeless value of games ultimately lost. For example,
          for the following position</para>
        <figure float="0" id="gnubg-fig_cubeful1A">
          <title>Cubeful example 1</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/cubefuleq-ex1.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para><application>GNU Backgammon</application> evaluates</para>
        <informaltable frame="all">
          <tgroup cols="6">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <colspec colname="c3" colnum="3" colwidth="1*"/>
            <colspec colname="c4" colnum="4" colwidth="1*"/>
            <colspec colname="c5" colnum="5" colwidth="1*"/>
            <colspec colname="c6" colnum="6" colwidth="1*"/>
            <tbody>
              <row>
                <entry> </entry>
                <entry>Win</entry>
                <entry>W(g)</entry>
                <entry>W(bg)</entry>
                <entry>L(g)</entry>
                <entry>L(bg)</entry>
              </row>
              <row>
                <entry>static:</entry>
                <entry>0.454</entry>
                <entry>0.103</entry>
                <entry>0.001</entry>
                <entry>0.106</entry>
                <entry>0.003</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <para>and hence W=(0.454 + 0.103 + 0.001)/0.454=1.229 and
          L=(0.556+0.106+0.003)/0.556) = 1.196. For gammon-free positions, e.g.,
          a race, W=1 and L=1.</para>
        <para>The live cube equity is now based on piecewise linear
          interpolation between the points (0%,-L), (TP,-1), (CP,+1), and
          (100%,+W): if my winning chance is 0 I lose L points, at my take point
          I lose 1 point, at my cash point I cash 1 point, and when I have a
          certain win I win W points:</para>
        <figure float="0" id="gnubg-fig_mgtp">
          <title>mgtp</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/mgtp.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>For match play there is no simple formula, since redoubles can
          only occur a limited number of times.</para>
        <para>The live cube take point is generally calculated as</para>
        <para>TP(live, n Cube)=TP(dead, n cube) * (1 - TP(live, 2n cube)</para>
        <para>So to calculate the live cube take points for a 1-cube at 3-0 to 7
          we need the live cube take points for the 4-cube and the 2-cube. For
          the position above and using Woolsey's match equity table the live
          cube take point are:</para>
        <informaltable frame="all">
          <tgroup cols="3">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <colspec colname="c3" colnum="3" colwidth="1*"/>
            <tbody>
              <row>
                <entry>Cube value </entry>
                <entry>TP for Black </entry>
                <entry>TP for White</entry>
                <entry> </entry>
<entry> </entry>
</row>
              <row>
                <entry>4</entry>
                <entry>0%</entry>
                <entry>41%</entry>
              </row>
              <row>
                <entry>2</entry>
                <entry>15%</entry>
                <entry>38.5%</entry>
              </row>
              <row>
                <entry>1</entry>
                <entry>24.5%</entry>
                <entry>27.3%</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <para>The calculation of these are left as an exercise to the reader.</para>
        <para>Ignoring backgammons, the gammon rates for White and Black are
          0.106/54.6=19% and 0.103/0.454=22%, respectively. If White wins the
          game his MWC will be</para>
        <para>81% * MWC(-3,-7) + 19% * MWC(-2,-7) = 78%</para>
        <para>and if Black wins his MWC will be</para>
        <para>78% * MWC(-4,-6) + 22% * MWC(-4,-5) = 41%.</para>
        <para>If White cashes 1 point he has MWC(-3,-7)=76% and if Black cashes
          he has MWC(-4,-6)=36%. Analogous to money game the live cube MWC is
          calculated as piecewise linear interpolation between (0%,22%),
          (24.5%,24%), (72.7%,36%), and (100%,41%) (from black's point of view):</para>
        <figure float="0" id="gnubg-fig_mptp">
          <title>mptp</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/mptp.png"/>
            </imageobject>
          </mediaobject>
        </figure>
      </sect4>
      <sect4 id="gnubg-tech_equities_cubeful_0ply">
        <title>0-ply Cubeful equities</title>
        <para>Having established the live cube equities and MWCs we're now in
          position to calculate the 0-ply cubeful equities.</para>
        <para>Let's start with money game: the cubeless equity is -0.097 and the
          live cube equity can be determined from the figure above as -0.157.
          Thus, the cubeful equity is -0.138.</para>
        <para>For the match play example at the score 3-0 the cubeless MWC is
          29.1% and from the figure Black using wins=45.4% we can determine the
          live cube MWC to be 29.2%. Using a value of x=0.68 we arrive at a
          cubeful MWC of 29.17%.</para>
      </sect4>
      <sect4 id="gnubg-tech_equities_cubeful_nply">
        <title>n-ply Cubeful equities</title>
        <para>The previous section concerned the calculation of 0-ply cubeful
          equities, so how so <application>GNU Backgammon</application>
          calculate cubeful 2-ply equities? The answer is: by simple recursion:</para>
        <para>Equity=0</para>
        <para>Loop over 21 dice rolls</para>
        <para>Find best move for given roll</para>
        <para>Equity = Equity + Evaluate n-1 ply equity for resulting position</para>
        <para>End Loop</para>
        <para>Equity = Equity/36</para>
        <para>Note that evaluating the n-1 ply equity involves a cube decision,
          since the opponent may double, so <application>GNU
          Backgammon</application> will actually calculate the two n-1 ply
          equities: (a) assuming no double, and (b) assuming double, take. These
          two equities are combined with the equity for a pass, and the optimum
          of these three is added to the resulting equity. For a cubeful 2-ply
          evaluation <application>GNU Backgammon</application> will end up
          calculating the following cubeful 0-ply equities: centered 1-cube,
          opponent owns 2-cube, owned 4-cube, and opponent owns 8-cube.</para>
        <para>Note that the 2-ply level does not use the cube efficiency, it's
          not used until at the 0-ply level, but it's possible to calculate an
          effective one by isolating x in the basic cube formula:</para>
        <para>x(eff) = (E(2-ply cubeful) - E(2-ply dead))/(E(2-ply live)-E(2-ply
          dead)).</para>
      </sect4>
      <sect4 id="gnubg-tech_equities_cubeful_efficiency">
        <title>The cube efficiency</title>
        <para>The cube efficiency is obviously an important parameter,
          unfortunately there haven't been much investigation carried out, so
            <application>GNU Backgammon</application> basically uses the values
          0.6-0.7 originally suggested by Rick Janowski:</para>
        <informaltable frame="all">
          <tgroup cols="2">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <tbody>
              <row>
                <entry>Position Class </entry>
                <entry>x (Cube efficiency)</entry>
                <entry> </entry>
</row> <row>
                <entry>Two-sided (exact) bearoff</entry>
                <entry>n/a</entry>
              </row>
              <row>
                <entry>One-sided bearoff</entry>
                <entry>0.6</entry>
              </row>
              <row>
                <entry>Crashed</entry>
                <entry>0.68</entry>
              </row>
              <row>
                <entry>Contact</entry>
                <entry>0.68</entry>
              </row>
              <row>
                <entry>Race</entry>
                <entry>linear interpolation between 0.6 and 0.7</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <para>For race <application>GNU Backgammon</application> uses linear
          interpolation based on pip count for the player on roll. A pip count
          of 40 gives x=0.6 and 120 gives x=0.7. If the pip count is below 40 or
          above 120 values of x=0.6 and x=0.7 are used, respectively.</para>
        <para>For the two sided bearoff positions the cubeful money equity is
          already available from the database, so for money game there is no
          need to calculate cubeful equities via Janowski's formula. However,
          the cubeful equities for money game cannot be used for match play.
          Instead of using a fixed value of x, say, 0.6, <application>GNU
            Backgammon</application> will calculate an effective value based on
          the cubeful money equity. The cubeful MWC is calculated as usual, but
          with the calculated x.</para>
        <para>There is obviously room for improvements. For example, holding
          games should intuitively have a lower cube efficiency, since it's very
          difficult to double effectively: either it's not good enough or you've
          lost the market by a mile after rolling a high double or hitting a
          single shot. Similarly, backgames will often have a low cube
          efficiency, whereas blitzes have may have a higher cube
        efficiency.</para>
      </sect4>
      <sect4 id="gnubg-tech_equities_cubeful_decisions">
        <title>Cube decisions</title>
        <para><application>GNU Backgammon</application>'s cube decisions are
          simple based on calculations of cubeful equities. For a double
          decision <application>GNU Backgammon</application> calculates the
          cubeful equity for <emphasis>no double</emphasis> and the cubeful
          equity for <emphasis>double, take</emphasis>. Combined with the equity
          for <emphasis>double, pass</emphasis>, it's possible to determine the
          correct cube action.</para>
        <para>The figure below shows the relevant cubeful equities for White and
          black's cube decisions in sample position from earlier.</para>
        <figure float="0" id="gnubg-fig_mgcd">
          <title>mgcd</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/mgcd.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>On 0-ply Black will double when the green curve (White owns
          2-cube) is above the red curve (centered cube), and White will take as
          long as the green curve is below 1. Similarly, White will double when
          the blue curve (Black owns 2-cube) is below the red curve (centered
          cube), and Black takes as long as the blue curve is above -1.</para>
        <para>Note that <application>GNU Backgammon</application> doesn't
          calculate the take point or double point explicitly. The cube decision
          is simply made by comparing equities from the figure.</para>
      </sect4>
      <sect4 id="gnubg-tech_equities_cubeful_beyond">
        <title>Beyond the simple model</title>
        <para>Janowski has developed two other models for cubeful equities. The
          first is a generalization of the one used by <application>GNU
            Backgammon</application>; it introduces two cube efficiencies
          instead of one. Often you may see that the cube efficiencies are
          different for the two players, and the <emphasis>refined general
          model</emphasis> as it is named by Janowski, tries to take this into
          consideration by using different cube efficiency parameters for the
          two players. For example, the blitzer may have another cube efficiency
          that the blitzee.</para>
        <para>The second model is not published, but redefines the cube
          efficiency into a value that can be understood more intuitively and
          calculate easily from rollouts.</para>
      </sect4>
      </sect3>
      </sect2>
        <sect2 id="gnubg-tech_postionid">
          <title>A technical description of the Position ID</title>
          <para>This section describes a method for compactly recording a
            backgammon position. It demonstrates how to encode a position into
            10 binary bytes, which is useful for minimizing the space used when
            recording large numbers of positions in memory or on disk. There is
            also an ASCII representation in 14 characters, which is convenient
            for output to the screen, for copying and pasting to transfer
            positions between programs which support the format, and for
            communicating positions via Usenet news or e-mail. The 10 byte
            binary format is called the key, and the 14 character ASCII format
            is the ID.</para>
          <para>The key is essentially a bit string (imagine you start with an
            empty sequence of bits, and continue adding either
            <emphasis>0</emphasis> or <emphasis>1</emphasis> to the end). The
            way to build up a sequence that corresponds to a given position is:</para>
          <orderedlist continuation="restarts" inheritnum="ignore">
            <listitem>
              <para>For every point around the board (starting at the ace point
                of the player on roll, continuing around to the 24 point and
                ending at the bar): </para>
            </listitem>
            <listitem>
              <para>append as many 1s as the player on roll has on that point
                (if any). </para>
            </listitem>
            <listitem>
              <para>append a 0. </para>
            </listitem>
            <listitem>
              <para>For every point around the board (starting at the ace point
                of the opponent, continuing around to the opponent's 24 point
                and ending at the bar): </para>
            </listitem>
            <listitem>
              <para>append as many 1s as the opponent has on that point (if
                any). </para>
            </listitem>
            <listitem>
              <para>append a 0. </para>
            </listitem>
            <listitem>
              <para>Pad out the string to 80 bits with 0s. </para>
            </listitem>
          </orderedlist>
          <para>The worst-case representation will require 80 bits: you can see
            that there are always 50 0 bits even if there are no checkers at
            all. Each player has a maximum of 15 checkers in play (not yet borne
            off) which require a 1 bit wherever they are positioned. That's 30
            bits to take of all checkers, plus the 50 bits of overhead for a
            total of 80 bits (the last bit is always 0 and isn't strictly
            necessary, but it makes the code slightly easier). This bit string
            should be stored in little-endian order when packed into bytes (i.e.
            the first bits in the string are stored in the least significant
            bits of the first byte).</para>
          <para>As an example, here's what the starting position looks like in
            the key format:</para>
          <informaltable frame="all">
            <tgroup cols="2">
              <colspec colname="c1" colnum="1" colwidth="1*"/>
              <colspec colname="c2" colnum="2" colwidth="1*"/>
              <tbody>
                <row>
                  <entry>0 0 0 0 0</entry>
                  <entry>player on roll has no checkers on ace to 5 points</entry>
                </row>
                <row>
                  <entry>11111 0</entry>
                  <entry>5 checkers on the 6 point</entry>
                </row>
                <row>
                  <entry>0</entry>
                  <entry>empty bar</entry>
                </row>
                <row>
                  <entry>111 0</entry>
                  <entry>3 on the 8</entry>
                </row>
                <row>
                  <entry>0 0 0 0</entry>
                  <entry>no others in our outfield</entry>
                </row>
                <row>
                  <entry>11111 0</entry>
                  <entry>5 on the midpoint</entry>
                </row>
                <row>
                  <entry>0 0 0 0 0</entry>
                  <entry>none in the opponent's outfield</entry>
                </row>
                <row>
                  <entry>0 0 0 0 0</entry>
                  <entry>or in opponent's board, until...</entry>
                </row>
                <row>
                  <entry>11 0</entry>
                  <entry>two on the 24 point</entry>
                </row>
                <row>
                  <entry>0</entry>
                  <entry>none on the bar</entry>
                </row>
                <row>
                  <entry>0 0 0 0 0</entry>
                  <entry>opponent has no checkers on ace to 5 points</entry>
                </row>
                <row>
                  <entry>11111 0</entry>
                  <entry>5 checkers on the 6 point</entry>
                </row>
                <row>
                  <entry>0</entry>
                  <entry>empty bar</entry>
                </row>
                <row>
                  <entry>111 0</entry>
                  <entry>3 on the 8</entry>
                </row>
                <row>
                  <entry>0 0 0 0</entry>
                  <entry>no others in opponent's outfield</entry>
                </row>
                <row>
                  <entry>11111 0</entry>
                  <entry>5 on the midpoint</entry>
                </row>
                <row>
                  <entry>0 0 0 0 0</entry>
                  <entry>none in our outfield</entry>
                </row>
                <row>
                  <entry>0 0 0 0 0</entry>
                  <entry>or in our board, until...</entry>
                </row>
                <row>
                  <entry>11 0</entry>
                  <entry>two on the 24 point</entry>
                </row>
                <row>
                  <entry>0</entry>
                  <entry>none on the bar</entry>
                </row>
              </tbody>
            </tgroup>
          </informaltable>
          <para>so altogether it's:</para>
          <para>00000111110011100000111110000000000011000000011111001110000011111000000000001100</para>
          <para>In little endian bytes it looks like:</para>
          <informaltable frame="all">
            <tgroup cols="6">
              <colspec colname="c1" colnum="1" colwidth="1*"/>
              <colspec colname="c2" colnum="2" colwidth="1*"/>
              <colspec colname="c3" colnum="3" colwidth="1*"/>
              <colspec colname="c4" colnum="4" colwidth="1*"/>
              <colspec colname="c5" colnum="5" colwidth="1*"/>
              <colspec colname="c6" colnum="6" colwidth="1*"/>
              <tbody>
                <row>
                  <entry>11100000</entry>
                  <entry>01110011</entry>
                  <entry>11110000</entry>
                  <entry>00000001</entry>
                  <entry>00110000</entry>
                  <entry>11100000</entry>
                  <entry>01110011</entry>
                  <entry>11110000</entry>
                  <entry>00000001</entry>
                  <entry>00110000</entry>
                </row>
                <row>
                  <entry>0xE0</entry>
                  <entry>0x73</entry>
                  <entry>0xF0</entry>
                  <entry>0x01</entry>
                  <entry>0x30</entry>
                  <entry>0xE0</entry>
                  <entry>0x73</entry>
                  <entry>0xF0</entry>
                  <entry>0x01</entry>
                  <entry>0x30</entry>
                </row>
              </tbody>
            </tgroup>
          </informaltable>
          <para>so the 10 byte key (in hex) is E0 73 F0 01 30 E0 73 F0 01
          30.</para>
          <para>The ID format is simply the <ulink url="http://www.ietf.org/rfc/rfc2045.txt">Base64</ulink> encoding
            of the key. (Technically, a Base64 encoding of 80 binary bits should
            consist of 14 characters followed by two = padding characters, but
            this padding is omitted in the ID format.)</para>
          <para>To continue the above example, splitting the 10 8-bit bytes into
            14 6-bit groups gives:</para>
          <para>111000 000111 001111 110000 000000 010011 000011 100000 011100
            111111 000000 000001 001100 000000</para>
          <para>In Base64 encoding, these groups are respectively represented
            as:</para>
          <para>4 H P w A T D g c / A B M A</para>
          <para>So, the position ID of the checkers at the start of the game is
            simply:</para>
          <para>4HPwATDgc/ABMA</para>
          <para>You can set the board in gnubg either by writing the position ID
            into the position text input field in the GUI or by executing the
            command</para>
          <para>set board 4HPwATDgc/ABMA.</para>
          <para><emphasis>Notes</emphasis></para>
          <orderedlist continuation="restarts" inheritnum="ignore">
            <listitem>
              <para>This encoding is obviously not as compact as it could be: in
                particular, there are lots of redundant representations of
                illegal positions where both players have checkers on the same
                point. Theoretically, it would be possible to get it down to 64
                bits by using <ulink url="http://www.bkgm.com/rgb/rgb.cgi?view+371">Walter Trice's </ulink>
                <ulink url="http://www.bkgm.com/rgb/rgb.cgi?view+371"><emphasis>D() expressions</emphasis></ulink>, but I think you'd have to be a mathematical masochist
                to try it! </para>
            </listitem>
            <listitem>
              <para><ulink url="http://savannah.gnu.org/cgi-bin/viewcvs/gnubg/gnubg/positionid.c?rev=HEAD&amp;sortby=date&amp;content-type=text/vnd.viewcvs-markup">Example code</ulink> to convert between a raw board encoding
                (the number of checkers on each point) and these keys/IDs is
                available licensed under GPL. </para>
            </listitem>
            <listitem>
              <para>Thanks to Tom Keith and David desJardins for their
                suggestions on simplifying the encoding without increasing the
                worst case length. </para>
            </listitem>
          </orderedlist>
      </sect2>
      <sect2 id="gnubg-tech_matchid">
        <title>A technical description of the Match ID</title>
        <para>This section describes how the match ID is calculated. The match
          ID can be used for easy exchange of positions for gnubg users in
          conjunction with the position ID. The match key is a 9 byte
          representation of the match score, match length, value of cube, owner
          of cube, Crawford game flag, player on roll, player to make a
          decision, doubled flag, resigned flag, and the dice rolled. The match
          ID is the 12 character Base64 encoding of the match key. Match key</para>
        <para>The match key is a bit string of length 66:</para>
        <informaltable frame="all">
          <tgroup cols="8">
            <tbody>
              <row>
                <entry>1-4</entry>
               <entry>5-6</entry>
               <entry>7</entry>
               <entry>8</entry>
               <entry>9-11</entry>
               <entry>12</entry>
               <entry>13</entry>
               <entry>14-15</entry>
               <entry>16-18</entry>
               <entry>19-21</entry>
               <entry>22-36</entry>
               <entry>37-51</entry>
               <entry>52</entry>
              </row>
              <row>
                <entry>Cube</entry>
                <entry>CubeOwner</entry>
                <entry>DiceOwner</entry>
                <entry>Crawford</entry>
                <entry>GameState</entry>
                <entry>TurnOwner</entry>
                <entry>Double</entry>
                <entry>Resign</entry>
                <entry>Dice1</entry>
                <entry>Dice2</entry>
                <entry>MatchLen x 15 </entry>
                <entry>Score1 x 15</entry>
                <entry>Score2 x 15</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <orderedlist continuation="restarts" inheritnum="ignore">
          <listitem>
            <para>Bit 1-4 contains the 2-logarithm of the cube value. For
              example, a 8-cube is encoded as 0011 binary (or 3), since 2 to the
              power of 3 is 8. The maximum value of the cube in with this
              encoding is 2 to the power of 15, i.e., a 32768-cube. </para>
          </listitem>
          <listitem>
            <para>Bit 5-6 contains the cube owner. 00 if player 0 owns the cube,
              01 if player 1 owns the cube, or 11 for a centered cube. </para>
          </listitem>
          <listitem>
            <para>Bit 7 is the player on roll or the player who did roll (0 and
              1 for player 0 and 1, respectively). </para>
          </listitem>
          <listitem>
            <para>Bit 8 is the Crawford flag: 1 if this game is the Crawford
              game, 0 otherwise. </para>
          </listitem>
          <listitem>
            <para>Bit 9-11 is the game state: 000 for no game started, 001 for
              playing a game, 010 if the game is over, 011 if the game was
              resigned, or 100 if the game was ended by dropping a cube. </para>
          </listitem>
          <listitem>
            <para>Bit 12 indicates whose turn it is. For example, suppose player
              0 is on roll then bit 7 above will be 0. Player 0 now decides to
              double, this will make bit 12 equal to 1, since it is now player
              1's turn to decide whether she takes or passes the cube. </para>
          </listitem>
          <listitem>
            <para>Bit 13 indicates whether an doubled is being offered. 0 if no
              double is being offered and 1 if a double is being offered.
            </para>
          </listitem>
          <listitem>
            <para>Bit 14-15 indicates whether an resignation was offered. 00 for
              no resignation, 01 for resign of a single game, 10 for resign of a
              gammon, or 11 for resign of a backgammon. The player offering the
              resignation is the inverse of bit 12, e.g., if player 0 resigns a
              gammon then bit 12 will be 1 (as it is now player 1 now has to
              decide whether to accept or reject the resignation) and bit 13-14
              will be 10 for resign of a gammon. </para>
          </listitem>
          <listitem>
            <para>Bit 16-18 and bit 19-21 is the first and second die,
              respectively. 0 if the dice has not yet be rolled, otherwise the
              binary encoding of the dice, e.g., if 5-2 was rolled bit 16-21
              will be 101-010. </para>
          </listitem>
          <listitem>
            <para>Bit 22 to 36 is the match length. The maximum value for the
              match length is 32767. A match score of zero indicates that the
              game is a money game. </para>
          </listitem>
          <listitem>
            <para>Bit 37-51 and bit 52-66 is the score for player 0 and player 1
              respectively. The maximum value of the match score is 32767.
            </para>
          </listitem>
        </orderedlist>
        <para>For example, assume the score is 2-4 in a 9 point match with
          player 0 holding a 2-cube, and player 1 has just rolled 52. The match
          key for this will be (note that the bit order is reversed below for
          readability)</para>
        <para>1000 00 1 0 100 1 0 00 101 010 100100000000000 010000000000000
          001000000000000</para>
        <para>In little endian the bytes looks like:</para>
        <para>01000001 10001001 00101010 00000001 00100000 00000000 00100000
          00000000 00</para>
        <para>0x41 0x89 0x2A 0x01 0x20 0x00 0x20 0x00 0x00</para>
        <para>Analogous to the position ID from the previous section the match
          ID format is simply the Base64 encoding of the key.</para>
        <para>To continue the example above, the 9 8-bit bytes are grouped into
          12 6-bits groups:</para>
        <para>010000 011000 100100 101010 000000 010010 000000 000000 001000
          000000 000000 000000</para>
        <para>In Base64 encoding, the groups are represented as:</para>
        <para>Q Y k q A S A A I A A A</para>
        <para>So, the match id is simply:</para>
        <para>QYkqASAAIAAA</para>
        <para>If someone post a match ID you can set up the position in gnubg by
          writing or pasting it into the Match ID text input field on the main
          window, or by executing the command</para>
        <para>set matchid QYkqASAAIAAA.</para>
      </sect2>
      <sect2 id="gnubg-tech_css">
        <title>Description of the CSS style sheet</title>
        <para>As mentioned above <application>GNU Backgammon</application>
          writes a CSS style sheet along with the generated XHTML file. The CSS
          style sheet may be written verbatim in the header section of the XHTML
          file, to an external file named gnubg.css, or inside the tags using
          the style attribute. If you wish to make any modifications to the
          style sheet without modifying the actual source code of
            <application>GNU Backgammon</application> you have to choose one of
          the first two methods. Note that the special export for Kit Woolsey's
          GammOnLine uses the third method since the XHTML is pasted into a web
          page without the possibility to modify the header section of the page
          where the style sheet is defined. Thus, it's not possible to modify
          the style of the generated XHTML for GammOnLine without modifications
          of the source code or extensive search and replace in the generated
          XHTML.</para>
        <para>Below follows a description of the CSS classes used in the XHTML
          export:</para>
        <informaltable frame="all">
          <tgroup cols="2">
            <tbody>
              <row>
                <entry>Class</entry>
                <entry>Description</entry>
              </row>
              <row>
                <entry>.movetable</entry>
                <entry>Style applied to the entire table used for the move analysis</entry>
              </row>
              <row>
                <entry>.moveheader</entry>
                <entry>The header of the move analysis table</entry>
              </row>
              <row>
                <entry>.movenumber</entry>
                <entry>The rank number of a move in the move analysis</entry>
              </row>
              <row>
                <entry>.moveply</entry>
                <entry>The column indicating the number of plies or rollout</entry>
              </row>
              <row>
                <entry>.movemove</entry>
                <entry>The formatted move, e.g., 13/7 8/7.</entry>
              </row>
              <row>
                <entry>.moveequity</entry>
                <entry>The column with the equity or MWC.</entry>
              </row>
              <row>
                <entry>.movethemove</entry>
                <entry>Special style for row that contains the actual move chosen by the player</entry>
              </row>
              <row>
                <entry>.moveodd</entry>
                <entry>Special style for the odd rows. Can be used to give an alternating color for the rows.</entry>
              </row>
              <row>
                <entry>.percent</entry>
                <entry>Style for the game winning probabilities and equities in the move analysis.</entry>
              </row>
              <row>
                <entry>.blunder</entry>
                <entry>Emphasis blunders, e.g., <emphasis>Alert: missed double</emphasis> or <emphasis>Alert: bad move</emphasis>.</entry>
              </row>
              <row>
                <entry>.joker</entry>
                <entry>Emphasis very good or bad rolls, e.g., <emphasis>Alert: unlucky roll</emphasis>.</entry>
              </row>
              <row>
                <entry>.stattable</entry>
                <entry>The style applied to the entire table with game, match, and session statistics</entry>
              </row>
              <row>
                <entry>.stattableheader</entry>
                <entry>The header row of the statistics table</entry>
              </row>
              <row>
                <entry>.result</entry>
                <entry>Style for the text indicating the outcome of the game or match, e.g., Jørn<emphasis> Thyssen wins 16 points</emphasis>.</entry>
              </row>
              <row>
                <entry>.tiny</entry>
                <entry>Currently unused.</entry>
              </row>
              <row>
                <entry>.cubedecision</entry>
                <entry>The style applied to the entire cube decision table</entry>
              </row>
              <row>
                <entry>.cubedecisionheader</entry>
                <entry>Style for the header row of the cube decision table</entry>
              </row>
              <row>
                <entry>.cubeequity</entry>
                <entry>Style for any equity or MWC in the cube decision table</entry>
              </row>
              <row>
                <entry>.cubeaction</entry>
                <entry>Style for the text indicating the correct cube action</entry>
              </row>
              <row>
                <entry>.cubeply</entry>
                <entry>Style for the text that states the level of evaluation</entry>
              </row>
              <row>
                <entry>.cubeprobs</entry>
                <entry>Style for the game winning probabilities in the cube decision table</entry>
              </row>
              <row>
                <entry>.comment</entry>
                <entry>The style applied to the entire table used for annotations or comments, e.g., the kibitzing from imported SGG files</entry>
              </row>
              <row>
                <entry>.commentheader</entry>
                <entry>The style applied to the header row of the annotations' table</entry>
              </row>
              <row>
                <entry>.number</entry>
                <entry>Currently unused</entry>
              </row>
              <row>
                <entry>.fontfamily</entry>
                <entry>Style applied to the entire body of the XHTML document.</entry>
              </row>
              <row>
                <entry>.block</entry>
                <entry>Style applied to the images in the export to avoid gaps between individual pictures both horizontally and vertically.</entry>
              </row>
              <row>
                <entry>.positionid</entry>
                <entry>Style for the Position ID and match ID.</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
    </sect2>
  </sect1>
  <sect1 id="gnubg-faq">
    <title>Frequently Asked Questions</title>
    <sect2 id="gnubg-faq_general">
      <title>General questions</title>
      <sect3 id="gnubg-faq_general_gnubg">
        <title>What is <application>GNU Backgammon</application>?</title>
        <para><application>GNU Backgammon</application> (gnubg) is a program for
          playing and analyzing backgammon positions, games and matches. It's
          based on a neural network. You may play <application>GNU
          Backgammon</application> using the command line or a graphical
          interface based on GTK+.</para>
      </sect3>
      <sect3 id="gnubg-faq_general_os">
        <title>What operating systems are supported?</title>
        <para>Currently, <application>GNU Backgammon</application> is actually
          designed for <emphasis>GNU/Linux</emphasis>. It also compiles and
          (hopefully) runs under <emphasis>*BSD, IRIX, Solaris</emphasis> and
            <emphasis>True64 Unix</emphasis>. Last but not least there are
          frequently binaries for <emphasis>MS Windows</emphasis>. It has also
          been ported to <emphasis>MacOS</emphasis>. When you successfully port
          GNU Backgammon to other operating systems, you are welcome to give us
          a note at <ulink url="mailto:bug-gnubg@gnu.org">the GNU backgammon
            mailing list.</ulink>
        </para>
      </sect3>
      <sect3 id="gnubg-faq_general_getit">
        <title>Where do I get it?</title>
        <para>The official website is <ulink url="http://www.gnubg.org/">http://www.gnubg.org</ulink>. Binaries and source code for
            <application>GNU Backgammon</application> can be downloaded from
          this site. Up to date source code can be accessed through <ulink url="https://savannah.gnu.org/cvs/?group=gnubg">CVS</ulink>.</para>
      </sect3>
      <sect3 id="gnubg-faq_general_pay">
        <title>What do I have to pay for <application>GNU
          Backgammon</application>?</title>
        <para><application>GNU Backgammon</application> is <emphasis>Free
            Software</emphasis> and is a part of the <emphasis>GNU
          Project</emphasis>. You may download it for free. For more information
          see the <ulink url="http://www.gnu.org/licenses/gpl.html">GNU General
            Public License</ulink>. But be aware that <application>GNU
            Backgammon</application> is not <emphasis>public domain
          software</emphasis> or <emphasis>shareware</emphasis> as you perhaps
          know from <emphasis>MS Windows</emphasis>.<application>GNU
          Backgammon</application> is free as in <emphasis> freedom </emphasis>,
          i.e. all the source code is there for you to inspect, change or
          distribute as long as you keep said license.</para>
      </sect3>
      <sect3 id="gnubg-faq_general_gnu">
        <title>This GNU stuff sounds interesting.</title>
        <para>Take a look at the <ulink url="http://www.gnu.org/">GNU home
          page</ulink>. It's also the page for Free Software Foundation.</para>
      </sect3>
      <sect3 id="gnubg-faq_general_backgammon">
        <title>I want to learn more about backgammon.</title>
        <para>A good place to start is <ulink url="http://www.bkgm.com/">Backgammon Galore</ulink>. For an extensive link collection, go to
            <ulink url="http://www.chicagopoint.com/links.html">Gammon
          Links.</ulink>
        </para>
      </sect3>
      <sect3 id="gnubg-faq_general_questions">
        <title>Though I really read all the documentation I still have
          questions.</title>
        <para>Send an email to <ulink url="mailto:bug-gnubg@gnu.org">the GNU
            backgammon mailing list.</ulink> If it is a bug, be sure to include
          the name of your operating system, the version of gnubg you use, and
          any error messages you receive. Try to describe exactly what happens
          before the error occurs.</para>
      </sect3>
      <sect3 id="gnubg-faq_general_ideas">
        <title>I want to make a few proposals. I have new ideas.</title>
        <para>You're welcome! Send an email with your suggestions to <ulink url="mailto:bug-gnubg@gnu.org">the GNU backgammon mailing
          list.</ulink>
        </para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-faq_install">
      <title>How to install</title>
      <sect3 id="gnubg-faq_install_other">
        <title>Do I need some other software to run <application>GNU
          Backgammon</application>?</title>
        <para>No. Everything you need is included in the binaries.</para>
        <para>If you want to use the 3D board version on Linux, you might have
          to install the additional libraries that can be found as well on
            <ulink url="http://www.gnubg.org/index.php?itemid=24">this
          page</ulink>. (acepoint's directory)</para>
      </sect3>
      <sect3 id="gnubg-faq_install_new">
        <title>I want to install a newer version.</title>
        <para>Go a head, your settings should be saved..</para>
      </sect3>
      <sect3 id="gnubg-faq_install_compile">
        <title>I would like to compile it from the source code.</title>
        <para>Good luck to you! Download the source code and make sure to read
          one of the two following two items.</para>
      </sect3>
      <sect3 id="gnubg-faq_install_compilelinux">
        <title>What software do I need for compiling under GNU/Linux?</title>
        <para>Unpack the <application>GNU Backgammon</application> snapshots and
          follow the instructions of the file `INSTALL'. </para>
      </sect3>
      <sect3 id="gnubg-faq_install_compilems">
        <title>What software do I need for compiling under MS Windows?</title>
        <para>Follow the instructions at <ulink url="http://www.gnubg.org/index.php?itemid=50">http://www.gnubg.org/index.php?itemid=50</ulink>.</para>
      </sect3>
      <sect3 id="gnubg-faq_install_nocompile">
        <title>It does not compile.</title>
        <para>Check that you have installed all necessary development packages.</para>
        <para>Look for warnings or errors during compiling. If you still don't
          have a clue, send a message to
        <email>bug-gnubg@gnu.org</email>.</para>
      </sect3>
      <sect3 id="gnubg-faq_install_cpu">
        <title>On what CPU will <application>GNU Backgammon</application> run
          fastest?</title>
        <para>Here is a list of CPU and Evaluations per second ( <menuchoice><guimenu>Analyze</guimenu><guimenuitem>Evaluation Speed</guimenuitem></menuchoice>). Feel free to add your CPU:</para>
        <informaltable frame="all">
          <tgroup cols="6">
            <tbody>
              <row>
                <entry>Evals/sec</entry>
                <entry>CPU</entry>
                <entry>System/Main board</entry>
                <entry>RAM</entry>
                <entry>OS </entry>
                <entry>GNUBG-Version</entry>
                <entry> </entry>
</row> <row>
                <entry>28450 *1</entry>
                <entry>AMD Sempron 3000+ (1800 MHz)</entry>
                <entry>K8T800-A</entry>
                <entry>1024 MB</entry>
                <entry>Win 2000</entry>
                <entry>0.14-mingw</entry>
              </row>
              <row>
                <entry>28000</entry>
                <entry>Intel Core Duo 1.66 GHz</entry>
                <entry>Mac mini Core Duo</entry>
                <entry>512 MB</entry>
                <entry>Win XP SP2</entry>
                <entry>0.14-mingw</entry>
              </row>
              <row>
                <entry>27000</entry>
                <entry>Intel Pentium M 735 (1.7 GHz)</entry>
                <entry>AOpen 1557-J</entry>
                <entry>1024 MB</entry>
                <entry>Win XP SP2</entry>
                <entry>0.14-mingw</entry>
              </row>
              <row>
                <entry>26000</entry>
                <entry>Celeron 331 2.66 GHz</entry>
                <entry>Dell Dimension 3100</entry>
                <entry>512 MB</entry>
                <entry>Win XP SP2</entry>
                <entry>0.14.3-devel</entry>
              </row>
              <row>
                <entry>24500</entry>
                <entry>Sempron 2800+ (rev E6_at_2000 MHz)</entry>
                <entry>Asus K8V-X</entry>
                <entry>768 MB</entry>
                <entry>Win XP SP2</entry>
                <entry>0.14.3-devel</entry>
              </row>
              <row>
                <entry>23000</entry>
                <entry>P4 2.8 GHz</entry>
                <entry>Asus P4P800D</entry>
                <entry>1024 MB</entry>
                <entry>Win XP SP2</entry>
                <entry>0.14.3-devel</entry>
              </row>
              <row>
                <entry>21759</entry>
                <entry>Athlon64 3000+ (32bit mode)</entry>
                <entry>Acer Aspire 1522</entry>
                <entry>512 MB</entry>
                <entry>Kubuntu 5.04</entry>
                <entry>0.14.3-devel</entry>
              </row>
              <row>
                <entry>21500 *1</entry>
                <entry>AMD Sempron 3000+ (1800 MHz)</entry>
                <entry>K8T800-A</entry>
                <entry>1024 MB</entry>
                <entry>Win 2000</entry>
                <entry>0.14.3-devel</entry>
              </row>
              <row>
                <entry>20120</entry>
                <entry>Athlon XP 2500+ (_at_1833 Mhz)</entry>
                <entry>MSI K7N-Delta2</entry>
                <entry>1024 MB</entry>
                <entry>Suse Linux 9.2</entry>
                <entry>0.14.3-devel</entry>
              </row>
              <row>
                <entry>20200</entry>
                <entry>Pentium M 1.7 GHz</entry>
                <entry>Sony Vaio Z1XSP</entry>
                <entry>512 MB</entry>
                <entry>FreeBSD 5.2</entry>
                <entry> </entry>
</row> <row>
                <entry>19515</entry>
                <entry>Intel Pentium M 0.8 GHz *2</entry>
                <entry>Sony Vaio PCG-SRX51P</entry>
                <entry>256 MB</entry>
                <entry>Fedora FC6(T3)</entry>
                <entry>0.14.3-devel</entry>
              </row>
              <row>
                <entry>19200</entry>
                <entry>Pentium M 1.6 GHz</entry>
                <entry>IBM X41</entry>
                <entry>1024 MB</entry>
                <entry>Win XP SP2</entry>
                <entry>0.14.3-devel</entry>
              </row>
              <row>
                <entry>16900</entry>
                <entry>P4 2 GHz</entry>
                <entry>?</entry>
                <entry>256 MB</entry>
                <entry>Win 2000</entry>
                <entry>0.14-devel</entry>
              </row>
              <row>
                <entry>14400</entry>
                <entry>P3 1GHz</entry>
                <entry>Sony Vaio PCG-R600HFPD</entry>
                <entry>256 MB</entry>
                <entry>Win XP SP2</entry>
                <entry>0.16-mingw</entry>
              </row>
              <row>
                <entry>13000 *3</entry>
                <entry>AMD 1GHz</entry>
                <entry>Jetway</entry>
                <entry>1536 MB</entry>
                <entry>Win 2000</entry>
                <entry>0.14-devel</entry>
              </row>
              <row>
                <entry>10506</entry>
                <entry>Intel Pentium M 0.8 GHz</entry>
                <entry>Sony Vaio PCG-SRX51P</entry>
                <entry>256 MB</entry>
                <entry>Windows XP(SP2)</entry>
                <entry>0.14-mingw</entry>
              </row>
              <row>
                <entry>6200</entry>
                <entry>Celeron 650 MHz</entry>
                <entry>toshiba laptop</entry>
                <entry>256 MB</entry>
                <entry>Win me</entry>
                <entry>0.14-devel</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <informaltable frame="all">
          <tgroup cols="2">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <tbody>
              <row>
                <entry>*1</entry>
                <entry>These are the two versions evaluated on the same machine. Big difference!</entry>
              </row>
              <row>
                <entry>*2</entry>
                <entry>According to cat /proc/cpuinfo</entry>
              </row>
              <row>
                <entry>*3</entry>
                <entry>Highly variable: 12000 .. 13700</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
      </sect3>
    </sect2>
    <sect2 id="gnubg-faq_start">
      <title>Running <application>GNU Backgammon</application></title>
      <sect3 id="gnubg-faq_start_error">
        <title>I get an error message when starting.</title>
        <para>Well, your computer wants to communicate with you. Give it a
          chance and read (and try to understand) what it is telling you. Then
          read the next items carefully:</para>
      </sect3>
      <sect3 id="gnubg-faq_start_missing">
        <title><application>GNU Backgammon</application> complains about missing
          files.</title>
        <para><application>GNU Backgammon</application> reads several different
          files at start-up. It will first try to read a file called gnubg.wd.
          This is a file which contains all the neural net weights and is
          necessary for the program to evaluate positions. If this file is not
          found, or found corrupted or with an incompatible version,
            <application>GNU Backgammon</application> will search for a weights
          file called gnubg.weights. This file also contains the neural net
          weights, but is stored in ASCII format. If none of these files are
          found, <application>GNU Backgammon</application> will start, but it
          will give you a warning about these missing files, and it will play
            <emphasis>very</emphasis> poorly.</para>
        <para><application>GNU Backgammon</application> will also read the
          bearoff databases at start-up. There are usually two bearoff
          databases. The first is called gnubg_os0.bd, and has stored data about
          the bearoff probabilities of all position where both players have 15
          or fewer checkers left on their six home board points. If this file is
          not found, <application>GNU Backgammon</application> will create a
          heuristic bearoff database for these positions. This database is a
          also called the 'One Sided Database', since it evaluates each player
          separately. The other bearoff database is called gnubg_ts0.bd. This
          bearoff database contains win probabilities for all bearoff positions
          with six or less checkers. It also contains cubeful equities (Money
          Game) for all the positions. If this file is not found at start-up,
            <application>GNU Backgammon</application> will evaluate late bearoff
          positions with the one sided bearoff database.</para>
      </sect3>
      <sect3 id="gnubg-faq_start_beginner">
        <title>Starting from the WinXP menu it plays like a beginner.</title>
        <para>Open the MS Windows menu and go to the entry for gnubg.
          Right-click with the mouse and choose `properties'. Check, if the
          `working path' is the same directory as the `*.exe'-file one line
          above. If not, adjust the working path.</para>
      </sect3>
      <sect3 id="gnubg-faq_start_screen">
        <title>My screen mixes up while starting <application>GNU
          Backgammon</application>.</title>
        <para>Install the newest driver for your graphic card. Be sure that you
          have chosen at least a desktop resolution of 65535 (16 bit color
          depth). If your card is a ATI Rage <emphasis>somewhat</emphasis> there
          still might be some problems with the graphical interface (GTK+) and
          MS Windows.</para>
      </sect3>
      <sect3 id="gnubg-faq_start_gtk">
        <title>I only get a command-line interface. Where is the nice board?</title>
        <para>Using MS Windows, just click on the correct menu entry
            (`<application>GNU Backgammon</application> for windows'). If it
          still doesn't work, check whether `c:\[path-to-your-gnubg]\gnubg.exe'
          exists or not.</para>
        <para>GNU/Linux users should check if <ulink url="http://www.gtk.org/">GTK+</ulink> is installed.</para>
      </sect3>
      <sect3 id="gnubg-faq_start_settings">
        <title>When I restart <application>GNU Backgammon</application> all my
          settings are gone.</title>
        <para>Did you save your settings <menuchoice><guimenu>Settings</guimenu><guimenuitem>Save settings</guimenuitem></menuchoice> before you quit?</para>
      </sect3>
      <sect3 id="gnubg-faq_start_cl">
        <title>I do not need this graphical stuff. Where is the terminal for
          commands?</title>
        <para>For <emphasis>GNU/Linux</emphasis> users: open a terminal and run
            <command>gnubg -t</command>.</para>
        <para><productname>MS Windows</productname> users: Look for a file
          called <command>gnubg-cli.exe</command> in <application>GNU
          Backgammon</application>'s install directory or open the MS Windows
          menu <menuchoice><guimenu>Start</guimenu><guimenuitem>Run...</guimenuitem></menuchoice> and type
          <command>c:\[path-to-your-gnubg]\gnubg-cli.exe</command>. There is
          also a menu entry GNU Backgammon Command Line Interface.</para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-faq_play">
      <title>Playing backgammon</title>
      <sect3 id="gnubg-faq_play_session">
        <title>What is the difference of a new game or match or session?</title>
        <para>When you start a new match, you will be asked to play to a certain
          amount of points (for example, 7 points). The player who firstly
          reaches this amount wins the match. Starting a new session means
          playing to an infinite amount. Be aware that the rules do slightly
          differ, mainly the Jacoby rule is applies to sessions and the Crawford
          to match play.</para>
      </sect3>
      <sect3 id="gnubg-faq_play_beaver">
        <title>What the heck is a beaver in Backgammon?</title>
        <para>A beaver is only allowed in a money game session. To beaver means
          to redouble, retaining control of the cube, immediately after your
          opponent doubles. For more information see the <ulink url="http://www.bkgm.com/glossary.html#B">glossary at Backgammon
            Galore</ulink>.</para>
      </sect3>
      <sect3 id="gnubg-faq_play_move">
        <title>How do I move the checkers?</title>
        <para>The easiest way to move checkers is to "<emphasis>drag and
          drop</emphasis>." Put your mouse pointer over a checker you want to
          move, press the left mouse button and drag the checker to the desired
          point, holding down the button while dragging.</para>
        <para>If you prefer to use mouse clicks, the left mouse button is for
          the left die shown on your board. Right click your mouse for the right
          die.</para>
        <para>If you always want the higher number displayed on the left, go to
          the menu <menuchoice><guimenu>Settings</guimenu><guimenuitem>Appearance</guimenuitem><guimenuitem> General </guimenuitem></menuchoice> and select Show higher die on left.</para>
      </sect3>
      <sect3 id="gnubg-faq_play_5">
        <title>Why am I allowed to place more than 5 checkers on a point?</title>
        <para>The official backgammon tournament rules allow to put all 15
          checkers on a point. If you want to play with a maximum of 5 checkers,
          go to the menu Settings and activate the Egyptian Rule. Notice, the
          Egyptian Rule is not in the standard rules of backgammon. The position
          evaluator in <application>GNU Backgammon</application> doesn't have a
          clue about how to evaluate positions according to the Egyptian rule
          either. It strongly recommended that this rule is not used if you're
          trying to learn backgammon.</para>
      </sect3>
      <sect3 id="gnubg-faq_play_poorly">
        <title><application>GNU Backgammon</application> plays poorly.</title>
        <para>Are you sure? If the answer is yes you should think about going to
          Monte Carlo this summer and win the Backgammon World Championship. If
          this plan fails, check whether the weights file is loaded at start-up.
          See also <xref linkend="gnubg-faq_start_missing"/></para>
      </sect3>
      <sect3 id="gnubg-faq_play_strong">
        <title><application>GNU Backgammon</application> is too strong for me.</title>
        <para>Go to the menu <menuchoice><guimenu>Settings</guimenu><guimenuitem>Players</guimenuitem></menuchoice> and change the values for Player 0. There is also a set
          of predefined settings you may choose from.</para>
      </sect3>
      <sect3 id="gnubg-faq_play_cheat">
        <title>I think the bot is cheating. It always gets good dice.</title>
        <para>In its default configuration, the dice generator does not cheat.
          In the menu Settings you may choose between different random dice
          generators. If you still think <application>GNU
          Backgammon</application> is cheating, program your own dice generator
          or roll manually. It doesn't cheat!</para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-faq_settings">
      <title>Settings</title>
      <sect3 id="gnubg-faq_settings_name">
        <title>Where can I change the name of the human player?</title>
        <para>Go to the menu <menuchoice><guimenu>Settings</guimenu><guimenuitem> Players....</guimenuitem></menuchoice> and click on Player 1. At the top there is a field to
          change the human player's name.</para>
      </sect3>
      <sect3 id="gnubg-faq_settings_colors">
        <title>How do I change the colors?</title>
        <para>Go to the menu <menuchoice><guimenu>Settings</guimenu><guimenuitem> Appearance </guimenuitem></menuchoice>. Here you may change the color of checkers, the points
          and the board itself.</para>
      </sect3>
      <sect3 id="gnubg-faq_settings_beeps">
        <title>How do I stop the annoying beeps?"</title>
        <para>Go to the menu<menuchoice><guimenu>Settings</guimenu><guimenuitem> Appearance </guimenuitem></menuchoice> and click on the `General' tab at the right. Disable the
          option `Beep on illegal input'.</para>
      </sect3>
      <sect3 id="gnubg-faq_settings_plies">
        <title>What are Plies?</title>
        <para>A ply describes how far <application>GNU Backgammon</application>
          evaluates the position. <emphasis>0-ply</emphasis> means that
            <application>GNU Backgammon</application> estimates the worth of the
          position as it is. A <emphasis>1-ply</emphasis> evaluation looks one
          step deeper, i.e. it evaluates the position after making the best
          possible move for each of the 21 different rolls and returns the
          averaged result. <emphasis>2-ply</emphasis> is another roll further
          and so on.</para>
        <para>The more plies you choose, the more you strengthen
            <application>GNU Backgammon</application>. Keep in mind that this
          will also decrease the playing speed.</para>
        <para>Note also that <emphasis>0-ply</emphasis> in <application>GNU
            Backgammon</application> is equivalent to the
          <emphasis>1-ply</emphasis> evaluation of Snowie.</para>
        <para>It's possible that Snowie's is a <emphasis>playing</emphasis> ply
          while gnubg's is a <emphasis>position evaluation</emphasis> ply. When
          playing at 1-ply Snowie will make each possible move for the player's
          roll (that's 1 ply) and analyze the resulting positions. Playing at
          2-ply it will take each of those positions and make all the opponent
          moves for all possible rolls (the 2nd ply) and then analyze the
          resulting positions. In <application>GNU Backgammon</application> the
          initial set of possible moves is taken for granted, i.e. not counted
          as a ply, because gnubg's plies are position evaluation plies. Thus,
          for each of those possible moves a 0-ply analysis is done. gnubg's
          discounting of the first set of moves perhaps makes the counting seem
          funny.</para>
        <para>Looking at it a different way, if you give <application>GNU
            Backgammon</application> a position and analyze it at 1-ply, it will
          make all the moves for all possible rolls (the 1st ply) and then
          analyze the resulting positions. With Snowie it will assume that the
          position arose from a move (that's a pretend 1st ply) then make all
          the moves for all possible rolls (the 2nd ply) and analyze them. This
          time it's Snowie that seems to be counting strangely.</para>
      </sect3>
      <sect3 id="gnubg-faq_settings_noise">
        <title>What is noise?</title>
        <para>Noise is a facility for disturbing <application>GNU
          Backgammon</application>'s 0-ply evaluation. Raising the noise level
          decreases its playing strength.</para>
      </sect3>
      <sect3 id="gnubg-faq_settings_reduced">
        <title>What is reduced evaluation?</title>
        <para>Reduced searches only work with 2-ply evaluations and deeper. It
          cuts the search for candidate moves to increase evaluation
        speed.</para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-faq_analysing">
      <title>Analyzing</title>
      <sect3 id="gnubg-faq_analysing_id">
        <title>What are these funny letters at the right bottom?</title>
        <para>You will find two small windows titled `Position' and `Match ID'
          at the bottom of the <application>GNU Backgammon</application> window.
          Here you may use the `position_id'- or `match_id'-format for setting
          up or copying positions.</para>
        <para>An explanation of both formats is found in the <application>GNU
            Backgammon</application>'s documentation.</para>
      </sect3>
      <sect3 id="gnubg-faq_analysing_edit">
        <title>How do I set up a position manually?</title>
        <para>Open a new game, match or session. If gnubg already rolls the
          dice, don't bother. Press `edit', and either type the position_id and
          press Enter on your keyboard, or use the mouse to set up the checkers.</para>
        <para>A mouse click at the border of the board empties the point. A left
          or right click sets up a certain amount of checkers depending on where
          exactly on the pip you click. Set up the cube with a right mouse click
          on it.</para>
        <para>You can also drag and drop checkers when holding down the Ctrl
          key.</para>
        <para>Finally, go to the menu and select `Game, Set turn' to choose the
          player on roll. The dice will then disappear.</para>
      </sect3>
      <sect3 id="gnubg-faq_analysing_import">
        <title>Which formats must I use to import matches and positions?</title>
        <para>Import of matches and positions from a number of file formats is
          possible: (.bkg) Hans Berliner's BKG Format, (.gam) GammonEmpire Game,
          (.gam) PartyGammon Game, (.mat) Jellyfish Match, (.pos) Jellyfish
          Position, (.sgf) Gnu Backgammon File, (.sgg) GamesGrid Save Game,
          (.tmg) TrueMoneyGames, (.txt) Snowie Text</para>
      </sect3>
      <sect3 id="gnubg-faq_analysing_sides">
        <title>How can I switch the players sides?</title>
        <para>Go to the menu `Game' and click on `Swap players'.</para>
      </sect3>
      <sect3 id="gnubg-faq_analysing_error">
        <title>What do <emphasis>!</emphasis> and <emphasis>?</emphasis> mean?</title>
        <para>After analyzing a game or a match <application>GNU
          Backgammon</application> is able to do some comments on checker play
          or cube decisions. Open the menu `Window, Game record' and you will
          see a list of the moves. If the actual move or cube decision differs
          from the best, <application>GNU Backgammon</application> will put a
          comment on it.</para>
        <para>The default settings are:</para>
        <informaltable frame="all">
          <tgroup cols="3">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <colspec colname="c3" colnum="3" colwidth="1*"/>
            <tbody>
              <row>
                <entry>-0.040</entry>
                <entry>(doubtful):</entry>
                <entry>?!</entry>
              </row>
              <row>
                <entry>-0.080</entry>
                <entry>(bad):</entry>
                <entry>?</entry>
              </row>
              <row>
                <entry>-0.160</entry>
                <entry>(very bad):</entry>
                <entry>??</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <para>You may change these comment in the menu `Window, Annotation'
          choosing another comment for moves and/or double</para>
        <note>
          <para>Why a ? move
          should be deemed worse than a ?! move - that's one of life's little
            mysteries.</para>
        </note>
      </sect3>
      <sect3 id="gnubg-faq_analysing_rate">
        <title>How is the error rate determined?</title>
        <para><application>GNU Backgammon</application> determines a player's
          strength according to it's average error (per move):</para>
        <informaltable frame="all">
          <tgroup cols="2">
            <colspec colname="c1" colnum="1" colwidth="1*"/>
            <colspec colname="c2" colnum="2" colwidth="1*"/>
            <tbody>
              <row>
                <entry>Average Error</entry>
                <entry>Skill Level</entry>
              </row>
              <row>
                <entry>0.000 .. 0.005</entry>
                <entry>Extra-terrestrial</entry>
              </row>
              <row>
                <entry>0.005 .. 0.010</entry>
                <entry>World class</entry>
              </row>
              <row>
                <entry>0.010 .. 0.015</entry>
                <entry>Expert</entry>
              </row>
              <row>
                <entry>0.015 .. 0.020</entry>
                <entry>Advanced</entry>
              </row>
              <row>
                <entry>0.020 .. 0.025</entry>
                <entry>Intermediate</entry>
              </row>
              <row>
                <entry>0.025 .. 0.030</entry>
                <entry>Beginner</entry>
              </row>
              <row>
                <entry>0.030 ..</entry>
                <entry>Novice</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
        <para>After analyzing a game, match or session you can see the summary
          in the menu `Analyze, ... statistics'. Note that you can't change the
          ranges of these values.</para>
      </sect3>
      <sect3 id="gnubg-faq_analysing_pips">
        <title>What does Pips mean?</title>
        <para>The pip count is a measurement showing the total number of pips
          required for a player to bear off all checkers from the current
          position. It can be regarded as a rough estimate of the
            <emphasis>raceness</emphasis> of the position – a player with a
          lower pip count may in many situations want to try to race, whilst the
          opponent (with the higher pip count) may want to try blocking/holding.
          See also the <ulink url="http://www.bkgm.com/gloss/lookup.cgi?pip+count">explanation on
            BackGammon Galore</ulink>.</para>
        <para>(For the non-english speaking community it might be helpful to
          know that when you roll a six and a five, the total pips of that roll
          is eleven.)</para>
      </sect3>
      <sect3 id="gnubg-faq_analysing_epc">
        <title>What does epc mean?</title>
        <para>When bearing off checkers, you may notice a display showing the
          current <emphasis>epc</emphasis> value (next to the display of
            <emphasis>Pips</emphasis>). The epc display can be turned on or off
          under menu <emphasis>Settings —&gt; Options —&gt;
          Display</emphasis> (at least in the current version, as of June 2005).</para>
        <para><emphasis>epc</emphasis> stands for Effective Pip Count, and is an
          alternative measurement of the <emphasis>goodness</emphasis> of the
          position. The usual pip count can be a misleading
          <emphasis>goodness</emphasis> estimate when both players are bearing
          off. What is more important (for making cubing decisions) is
            <emphasis>the expected number of rolls</emphasis> each player needs
          to bear off hes checkers.</para>
        <para>The effective pip count is defined as this expected number of
          remaining rolls, multiplied with the average number of pips in a roll,
          which is 8.167. (The average number of pips in a roll would be 7 if
          rolling a double wouldn't yield a double pip count – i.e. a double-6
          yields 24 pips, not 12.)</para>
        <para>Thus, epc takes into account not only the current pip count, but
          also the expected pip wastage:</para>
        <orderedlist continuation="restarts" inheritnum="ignore">
          <listitem>
            <para>effective pip count (epc) = pip count + expected pip wastage
            </para>
          </listitem>
        </orderedlist>
        <para>An example:</para>
        <orderedlist continuation="restarts" inheritnum="ignore">
          <listitem>
            <para>Position: 5 checkers on the 1-point, 4 checkers on the
              2-point. </para>
          </listitem>
          <listitem>
            <para>Pip count: 5x1 + 4x2 = 13 </para>
          </listitem>
          <listitem>
            <para>epc: 2.189 (expected number of remaining rolls) * 8.167 =
              17.878 </para>
          </listitem>
          <listitem>
            <para>Wasted: 17.878 - 13 = 4.878 </para>
          </listitem>
        </orderedlist>
        <para>It's clear (hopefully) that the expected pip wastage (and hence
          the <emphasis>epc</emphasis>) increases with more checkers on lower
          points (e.g. you get pip wastage when rolling a 6 to bear off a
          checker from the 2- or 1-point).</para>
        <para>It is further <ulink url="http://www.bkgm.com/gloss/lookup.cgi?effective+pip+count">explained on BackGammon Galore</ulink>, especially in a <ulink url="http://www.bkgm.com/rgb/rgb.cgi?view+1076">post by Douglas
          Zare</ulink>.</para>
        <para>How do one calculate the epc then, or the expected number of
          remaining rolls? Gnu BG uses the one-sided bearoff database, which
          contains the change of bearing off the final checker in any given
          number of rolls. A player would probably use some quite complicated
          heuristics (please see the aforementioned post by Douglas Zare,
            <emphasis>and do get back here and explain it!</emphasis>)</para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-faq_databases">
      <title>Databases</title>
      <sect3 id="gnubg-faq_databases_whatis">
        <title>What is the `Database' menu for?</title>
        <para>Go find a newer build if you still have the database.</para>
      </sect3>
    </sect2>
    <sect2 id="gnubg-faq_abbr">
      <title>Abbreviations</title>
      <sect3 id="gnubg-faq_abbr_gwc">
        <title>GWC</title>
        <para><emphasis>GWC</emphasis> is an abbreviation for game winning
          chances.</para>
      </sect3>
      <sect3 id="gnubg-faq_abbr_mwc">
        <title>MWC?</title>
        <para><emphasis>MWC</emphasis> is an abbreviation for match winning
          chances.</para>
      </sect3>
      <sect3 id="gnubg-faq_abbr_dp">
        <title>DP?</title>
        <para>In the menu `Analyze, Game/Match/Session statistics' you will see
          a window with some statistics. Near the bottom, you'll see four lines
          beginning with `Missed ... and Wrong ...'. <emphasis>dp</emphasis>
          means <emphasis>doubling point</emphasis> and describes a situation in
          the game, where you probably should have doubled your opponent.</para>
      </sect3>
      <sect3 id="gnubg-faq_abbr_cp">
        <title>CP?</title>
        <para>From Max Friis page <ulink url="http://xfriis.dk/maxfriis/bg/double.html">http://xfriis.dk/maxfriis/bg/double.html</ulink> Cash-point(CP) is:
            <emphasis>your opponent's take-point now seen from your side of the
            board (your cash-point which equals 100% minus your opponent's
            take-point</emphasis>). <application>GNU Backgammon</application>
          uses the term <emphasis>missed double below cash-point</emphasis>,
          which means that the player should have doubled, and had he done so,
          his opponent should take. <emphasis>. Missed double above CP</emphasis>
          in a similar way means that the correct cube-action was double pass.</para>
        <para>If you are the leader in the match, the relevant take- and
          double-points will often look something like this (where TP*=CP):</para>
        <figure float="0" id="gnubg-fig_doubleline">
          <title>The double line</title>
          <mediaobject>
            <imageobject>
              <imagedata fileref="images/doubleline.png"/>
            </imageobject>
          </mediaobject>
        </figure>
        <para>The double windows (intervals) are:</para>
        <para>[DP;CP] = Your double window! This window does not contain any
          information about redoubles but only the distance to the point where
          you do not want to play for the double amount of points.</para>
        <para>[TP;DP] = 100% minus your opponent's double window now.</para>
        <para>[reTP;reDP] = 100% minus your opponent's double window after he
          has taken.</para>
      </sect3>
      <sect3 id="gnubg-faq_abbr_tg">
        <title>TG?</title>
        <para><emphasis>TG</emphasis> is an abbreviation for <emphasis>too
          good</emphasis> (to double). It points to a situation in the game,
          where you probably should have kept the cube (mostly because of
          decent, sometimes very good, gammon chances) rather than double out
          your opponent.</para>
      </sect3>
      <sect3 id="gnubg-faq_abbr_epc">
        <title>epc?</title>
        <para>See <ulink url="http://www.gnubg.org/documentation/doku.php?id=gnu_backgammon_faq#52">What does </ulink>
          <ulink url="http://www.gnubg.org/documentation/doku.php?id=gnu_backgammon_faq#52"><emphasis>epc</emphasis></ulink>
          <ulink url="http://www.gnubg.org/documentation/doku.php?id=gnu_backgammon_faq#52"> mean?</ulink>
        </para>
        <para>
          <emphasis>This should be an internal link, not an external one. But I
            can't figure out how to link internally to a subsection.
          Anyone?</emphasis>
        </para>
      </sect3>
    </sect2>
  </sect1>
  <appendix id="legal" lang="en">
    <title lang="en">GNU Free Documentation License</title>
    <subtitle>Version 1.2, November 2002</subtitle>
    <anchor id="gfdl"/>
    <blockquote id="fsf-copyright">
      <para>Copyright (C) 2000,2001,2002 Free Software Foundation, Inc. 59
        Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted
        to copy and distribute verbatim copies of this license document, but
        changing it is not allowed. </para>
    </blockquote>
    <sect1 id="gfdl-0" role="NotInToc">
      <title>PREAMBLE</title>
      <para> The purpose of this License is to make a manual, textbook, or other
        functional and useful document "free" in the sense of freedom: to assure
        everyone the effective freedom to copy and redistribute it, with or
        without modifying it, either commercially or noncommercially.
        Secondarily, this License preserves for the author and publisher a way
        to get credit for their work, while not being considered responsible for
        modifications made by others. </para>
      <para> This License is a kind of "copyleft", which means that derivative
        works of the document must themselves be free in the same sense. It
        complements the GNU General Public License, which is a copyleft license
        designed for free software. </para>
      <para> We have designed this License in order to use it for manuals for
        free software, because free software needs free documentation: a free
        program should come with manuals providing the same freedoms that the
        software does. But this License is not limited to software manuals; it
        can be used for any textual work, regardless of subject matter or
        whether it is published as a printed book. We recommend this License
        principally for works whose purpose is instruction or reference. </para>
    </sect1>
    <sect1 id="gfdl-1" role="NotInToc">
      <title>APPLICABILITY AND DEFINITIONS</title>
      <para id="gfdl-doc"> This License applies to any manual or other work, in
        any medium, that contains a notice placed by the copyright holder saying
        it can be distributed under the terms of this License. Such a notice
        grants a world-wide, royalty-free license, unlimited in duration, to use
        that work under the conditions stated herein. The "Document", below,
        refers to any such manual or work. Any member of the public is a
        licensee, and is addressed as "you". You accept the license if you copy,
        modify or distribute the work in a way requiring permission under
        copyright law. </para>
      <para id="gfdl-mod-ver"> A "Modified Version" of the Document means any
        work containing the Document or a portion of it, either copied verbatim,
        or with modifications and/or translated into another language. </para>
      <para id="gfdl-secnd-sect"> A "Secondary Section" is a named appendix or a
        front-matter section of the Document that deals exclusively with the
        relationship of the publishers or authors of the Document to the
        Document's overall subject (or to related matters) and contains nothing
        that could fall directly within that overall subject. (Thus, if the
        Document is in part a textbook of mathematics, a Secondary Section may
        not explain any mathematics.) The relationship could be a matter of
        historical connection with the subject or with related matters, or of
        legal, commercial, philosophical, ethical or political position
        regarding them. </para>
      <para id="gfdl-inv-sect"> The "Invariant Sections" are certain Secondary
        Sections whose titles are designated, as being those of Invariant
        Sections, in the notice that says that the Document is released under
        this License. If a section does not fit the above definition of
        Secondary then it is not allowed to be designated as Invariant. The
        Document may contain zero Invariant Sections. If the Document does not
        identify any Invariant Sections then there are none. </para>
      <para id="gfdl-cov-text"> The "Cover Texts" are certain short passages of
        text that are listed, as Front-Cover Texts or Back-Cover Texts, in the
        notice that says that the Document is released under this License. A
        Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at
        most 25 words. </para>
      <para id="gfdl-transparent"> A "Transparent" copy of the Document means a
        machine-readable copy, represented in a format whose specification is
        available to the general public, that is suitable for revising the
        document straightforwardly with generic text editors or (for images
        composed of pixels) generic paint programs or (for drawings) some widely
        available drawing editor, and that is suitable for input to text
        formatters or for automatic translation to a variety of formats suitable
        for input to text formatters. A copy made in an otherwise Transparent
        file format whose markup, or absence of markup, has been arranged to
        thwart or discourage subsequent modification by readers is not
        Transparent. An image format is not Transparent if used for any
        substantial amount of text. A copy that is not "Transparent" is called
        "Opaque". </para>
      <para> Examples of suitable formats for Transparent copies include plain
        ASCII without markup, Texinfo input format, LaTeX input format, SGML or
        XML using a publicly available DTD, and standard-conforming simple HTML,
        PostScript or PDF designed for human modification. Examples of
        transparent image formats include PNG, XCF and JPG. Opaque formats
        include proprietary formats that can be read and edited only by
        proprietary word processors, SGML or XML for which the DTD and/or
        processing tools are not generally available, and the machine-generated
        HTML, PostScript or PDF produced by some word processors for output
        purposes only. </para>
      <para id="gfdl-title-page"> The "Title Page" means, for a printed book,
        the title page itself, plus such following pages as are needed to hold,
        legibly, the material this License requires to appear in the title page.
        For works in formats which do not have any title page as such, "Title
        Page" means the text near the most prominent appearance of the work's
        title, preceding the beginning of the body of the text. </para>
      <para id="gfdl-entitled"> A section "Entitled XYZ" means a named subunit
        of the Document whose title either is precisely XYZ or contains XYZ in
        parentheses following text that translates XYZ in another language.
        (Here XYZ stands for a specific section name mentioned below, such as
        "Acknowledgements", "Dedications", "Endorsements", or "History".) To
        "Preserve the Title" of such a section when you modify the Document
        means that it remains a section "Entitled XYZ" according to this
        definition. </para>
      <para> The Document may include Warranty Disclaimers next to the notice
        which states that this License applies to the Document. These Warranty
        Disclaimers are considered to be included by reference in this License,
        but only as regards disclaiming warranties: any other implication that
        these Warranty Disclaimers may have is void and has no effect on the
        meaning of this License. </para>
    </sect1>
    <sect1 id="gfdl-2" role="NotInToc">
      <title>VERBATIM COPYING</title>
      <para> You may copy and distribute the Document in any medium, either
        commercially or noncommercially, provided that this License, the
        copyright notices, and the license notice saying this License applies to
        the Document are reproduced in all copies, and that you add no other
        conditions whatsoever to those of this License. You may not use
        technical measures to obstruct or control the reading or further copying
        of the copies you make or distribute. However, you may accept
        compensation in exchange for copies. If you distribute a large enough
        number of copies you must also follow the conditions in section3. </para>
      <para> You may also lend copies, under the same conditions stated above,
        and you may publicly display copies. </para>
    </sect1>
    <sect1 id="gfdl-3" role="NotInToc">
      <title>COPYING IN QUANTITY</title>
      <para> If you publish printed copies (or copies in media that commonly
        have printed covers) of the Document, numbering more than 100, and the
        Document's license notice requires Cover Texts, you must enclose the
        copies in covers that carry, clearly and legibly, all these Cover Texts:
        Front-Cover Texts on the front cover, and Back-Cover Texts on the back
        cover. Both covers must also clearly and legibly identify you as the
        publisher of these copies. The front cover must present the full title
        with all words of the title equally prominent and visible. You may add
        other material on the covers in addition. Copying with changes limited
        to the covers, as long as they preserve the title of the Document and
        satisfy these conditions, can be treated as verbatim copying in other
        respects. </para>
      <para> If the required texts for either cover are too voluminous to fit
        legibly, you should put the first ones listed (as many as fit
        reasonably) on the actual cover, and continue the rest onto adjacent
        pages. </para>
      <para> If you publish or distribute Opaque copies of the Document
        numbering more than 100, you must either include a machine-readable
        Transparent copy along with each Opaque copy, or state in or with each
        Opaque copy a computer-network location from which the general
        network-using public has access to download using public-standard
        network protocols a complete Transparent copy of the Document, free of
        added material. If you use the latter option, you must take reasonably
        prudent steps, when you begin distribution of Opaque copies in quantity,
        to ensure that this Transparent copy will remain thus accessible at the
        stated location until at least one year after the last time you
        distribute an Opaque copy (directly or through your agents or retailers)
        of that edition to the public. </para>
      <para> It is requested, but not required, that you contact the authors of
        the Document well before redistributing any large number of copies, to
        give them a chance to provide you with an updated version of the
        Document. </para>
    </sect1>
    <sect1 id="gfdl-4">
      <title>MODIFICATIONS</title>
      <para> You may copy and distribute a Modified Version of the Document
        under the conditions of sections 2 and 3 above, provided that you
        release the Modified Version under precisely this License, with the
        Modified Version filling the role of the Document, thus licensing
        distribution and modification of the Modified Version to whoever
        possesses a copy of it. In addition, you must do these things in the
        Modified Version: </para>
      <orderedlist continuation="restarts" id="gfdl-modif-cond" inheritnum="ignore" numeration="upperalpha">
        <listitem>
          <simpara> Use in the Title Page (and on the covers, if any) a title
            distinct from that of the Document, and from those of previous
            versions (which should, if there were any, be listed in the History
            section of the Document). You may use the same title as a previous
            version if the original publisher of that version gives permission.
          </simpara>
        </listitem>
        <listitem>
          <simpara> List on the Title Page, as authors, one or more persons or
            entities responsible for authorship of the modifications in the
            Modified Version, together with at least five of the principal
            authors of the Document (all of its principal authors, if it has
            fewer than five), unless they release you from this requirement.
          </simpara>
        </listitem>
        <listitem>
          <simpara> State on the Title page the name of the publisher of the
            Modified Version, as the publisher. </simpara>
        </listitem>
        <listitem>
          <simpara> Preserve all the copyright notices of the Document.
          </simpara>
        </listitem>
        <listitem>
          <simpara> Add an appropriate copyright notice for your modifications
            adjacent to the other copyright notices. </simpara>
        </listitem>
        <listitem>
          <simpara> Include, immediately after the copyright notices, a license
            notice giving the public permission to use the Modified Version
            under the terms of this License, in the form shown in the section
            Addendum below. </simpara>
        </listitem>
        <listitem>
          <simpara> Preserve in that license notice the full lists of Invariant
            Sections and required Cover Texts given in the Document's license
            notice. </simpara>
        </listitem>
        <listitem>
          <simpara> Include an unaltered copy of this License. </simpara>
        </listitem>
        <listitem>
          <simpara> Preserve the section Entitled "History", Preserve its Title,
            and add to it an item stating at least the title, year, new authors,
            and publisher of the Modified Version as given on the Title Page. If
            there is no section Entitled "History" in the Document, create one
            stating the title, year, authors, and publisher of the Document as
            given on its Title Page, then add an item describing the Modified
            Version as stated in the previous sentence. </simpara>
        </listitem>
        <listitem>
          <simpara> Preserve the network location, if any, given in the Document
            for public access to a Transparent copy of the Document, and
            likewise the network locations given in the Document for previous
            versions it was based on. These may be placed in the "History"
            section. You may omit a network location for a work that was
            published at least four years before the Document itself, or if the
            original publisher of the version it refers to gives permission.
          </simpara>
        </listitem>
        <listitem>
          <simpara> For any section Entitled "Acknowledgements" or
            "Dedications", Preserve the Title of the section, and preserve in
            the section all the substance and tone of each of the contributor
            acknowledgements and/or dedications given therein. </simpara>
        </listitem>
        <listitem>
          <simpara> Preserve all the Invariant Sections of the Document,
            unaltered in their text and in their titles. Section numbers or the
            equivalent are not considered part of the section titles. </simpara>
        </listitem>
        <listitem>
          <simpara> Delete any section Entitled "Endorsements". Such a section
            may not be included in the Modified Version. </simpara>
        </listitem>
        <listitem>
          <simpara> Do not retitle any existing section to be Entitled
            "Endorsements" or to conflict in title with any Invariant Section.
          </simpara>
        </listitem>
        <listitem>
          <simpara> Preserve any Warranty Disclaimers. </simpara>
        </listitem>
      </orderedlist>
      <para> If the Modified Version includes new front-matter sections or
        appendices that qualify as Secondary Sections and contain no material
        copied from the Document, you may at your option designate some or all
        of these sections as invariant. To do this, add their titles to the list
        of Invariant Sections in the Modified Version's license notice. These
        titles must be distinct from any other section titles. </para>
      <para> You may add a section Entitled "Endorsements", provided it contains
        nothing but endorsements of your Modified Version by various
        parties--for example, statements of peer review or that the text has
        been approved by an organisation as the authoritative definition of a
        standard. </para>
      <para> You may add a passage of up to five words as a Front-Cover Text,
        and a passage of up to 25 words as a Back-Cover Text, to the end of the
        list of Cover Texts in the Modified Version. Only one passage of
        Front-Cover Text and one of Back-Cover Text may be added by (or through
        arrangements made by) any one entity. If the Document already includes a
        cover text for the same cover, previously added by you or by arrangement
        made by the same entity you are acting on behalf of, you may not add
        another; but you may replace the old one, on explicit permission from
        the previous publisher that added the old one. </para>
      <para> The author(s) and publisher(s) of the Document do not by this
        License give permission to use their names for publicity for orto assert
        or imply endorsement of any Modified Version. </para>
    </sect1>
    <sect1 id="gfdl-5" role="NotInToc">
      <title>COMBINING DOCUMENTS</title>
      <para> You may combine the Document with other documents released under
        this License, under the terms defined in section 4 above for modified
        versions, provided that you include in the combination all of the
        Invariant Sections of all of the original documents, unmodified, and
        list them all as Invariant Sections of your combined work in its license
        notice, and that you preserve all their Warranty Disclaimers. </para>
      <para> The combined work need only contain one copy of this License, and
        multiple identical Invariant Sections may be replaced with a single
        copy. If there are multiple Invariant Sections with the same name but
        different contents, make the title of each such section unique by adding
        at the end of it, in parentheses, the name of the original author or
        publisher of that section if known, or else a unique number. Make the
        same adjustment to the section titles in the list of Invariant Sections
        in the license notice of the combined work. </para>
      <para> In the combination, you must combine any sections Entitled
        "History" in the various original documents, forming one section
        Entitled "History"; likewise combine any sections Entitled
        "Acknowledgements", and any sections Entitled "Dedications". You must
        delete all sections Entitled "Endorsements". </para>
    </sect1>
    <sect1 id="gfdl-6" role="NotInToc">
      <title>COLLECTIONS OF DOCUMENTS</title>
      <para> You may make a collection consisting of the Document and other
        documents released under this License, and replace the individual copies
        of this License in the various documents with a single copy that is
        included in the collection, provided that you follow the rules of this
        License for verbatim copying of each of the documents in all other
        respects. </para>
      <para> You may extract a single document from such a collection, and
        distribute it individually under this License, provided you insert a
        copy of this License into the extracted document, and follow this
        License in all other respects regarding verbatim copying of that
        document. </para>
    </sect1>
    <sect1 id="gfdl-7" role="NotInToc">
      <title>AGGREGATION WITH INDEPENDENT WORKS</title>
      <para> A compilation of the Document or its derivatives with other
        separate and independent documents or works, in or on a volume of a
        storage or distribution medium, is called an "aggregate" if the
        copyright resulting from the compilation is not used to limit the legal
        rights of the compilation's users beyond what the individual works
        permit. When the Document is included in an aggregate, this License does
        not apply to the other works in the aggregate which are not themselves
        derivative works of the Document. </para>
      <para> If the Cover Text requirement of section 3 is applicable to these
        copies of the Document, then if the Document is less than one half of
        the entire aggregate, the Document's Cover Texts may be placed on covers
        that bracket the Document within the aggregate, or the electronic
        equivalent of covers if the Document is in electronic form. Otherwise
        they must appear on printed covers that bracket the whole aggregate.
      </para>
    </sect1>
    <sect1 id="gfdl-8" role="NotInToc">
      <title>TRANSLATION</title>
      <para> Translation is considered a kind of modification, so you may
        distribute translations of the Document under the terms of section 4.
        Replacing Invariant Sections with translations requires special
        permission from their copyright holders, but you may include
        translations of some or all Invariant Sections in addition to the
        original versions of these Invariant Sections. You may include a
        translation of this License, and all the license notices in the
        Document, and any Warranty Disclaimers, provided that you also include
        the original English version of this License and the original versions
        of those notices and disclaimers. In case of a disagreement between the
        translation and the original version of this License or a notice or
        disclaimer, the original version will prevail. </para>
      <para> If a section in the Document is Entitled "Acknowledgements",
        "Dedications", or "History", the requirement (section 4) to Preserve its
        Title (section 1) will typically require changing the actual title.
      </para>
    </sect1>
    <sect1 id="gfdl-9" role="NotInToc">
      <title>TERMINATION</title>
      <para> You may not copy, modify, sublicense, or distribute the Document
        except as expressly provided for under this License. Any other attempt
        to copy, modify, sublicense or distribute the Document is void, and will
        automatically terminate your rights under this License. However, parties
        who have received copies, or rights, from you under this License will
        not have their licenses terminated so long as such parties remain in
        full compliance. </para>
    </sect1>
    <sect1 id="gfdl-10" role="NotInToc">
      <title>FUTURE REVISIONS OF THIS LICENSE</title>
      <para> The Free Software Foundation may publish new, revised versions of
        the GNU Free Documentation License from time to time. Such new versions
        will be similar in spirit to the present version, but may differ in
        detail to address new problems or concerns. See
        http://www.gnu.org/copyleft/. </para>
      <para> Each version of the License is given a distinguishing version
        number. If the Document specifies that a particular numbered version of
        this License "or any later version" applies to it, you have the option
        of following the terms and conditions either of that specified version
        or of any later version that has been published (not as a draft) by the
        Free Software Foundation. If the Document does not specify a version
        number of this License, you may choose any version ever published (not
        as a draft) by the Free Software Foundation. </para>
    </sect1>
    <sect1 id="gfdl-addendum">
      <title>ADDENDUM: How to use this License for your documents</title>
      <para> To use this License in a document you have written, include a copy
        of the License in the document and put the following copyright and
        license notices just after the title page: </para>
      <blockquote id="copyright-sample">
        <para> Copyright (c) YEAR YOUR NAME. Permission is granted to copy,
          distribute and/or modify this document under the terms of the GNU Free
          Documentation License, Version 1.2 or any later version published by
          the Free Software Foundation; with no Invariant Sections, no
          Front-Cover Texts, and no Back-Cover Texts. A copy of the license is
          included in the section entitled "GNU Free Documentation License".
        </para>
      </blockquote>
      <para> If you have Invariant Sections, Front-Cover Texts and Back-Cover
        Texts, replace the "with...Texts." line with this: </para>
      <blockquote id="inv-cover-sample">
        <para> with the Invariant Sections being LIST THEIR TITLES, with the
          Front-Cover Texts being LIST, and with the Back-Cover Texts being
          LIST. </para>
      </blockquote>
      <para> If you have Invariant Sections without Cover Texts, or some other
        combination of the three, merge those two alternatives to suit the
        situation. </para>
      <para> If your document contains nontrivial examples of program code, we
        recommend releasing these examples in parallel under your choice of free
        software license, such as the GNU General Public License, to permit
        their use in free software. </para>
    </sect1>
  </appendix>
</article>
<!-- End Move Analysis -->
<!-- Epilogue -->
<!-- Output generated  by GNU Backgammon 0.16-devel (http://www.gnu.org/software/gnubg/)  (HTML Export version 1.175) -->
