Programming

 How to count plies?

 From: Chuck Bower Address: bower@astro.indiana.edu Date: 11 January 2004 Subject: definition of "ply" forever muddied? Forum: GammOnLine

```In his report on the World Computer Olympiad here, Achim mentions that
gnubg's 2-ply is equivalent to "the NON-UNIX world's 3-ply"
(paraphrased). Is there any backgammon software besides Snowie that
messes this up?

At one time I thought Jellyfish might have had this wrong, but that is
clearly not the case. Jellyfish has pulldown functions for "Evaluate"
"level-7").

I think Snowie/Oasya get's the credit for starting this mislabelling,
and I hope it stops there.
```

 Achim Mueller  writes: ```Yes, there is at least one program: BGBlitz (http://www.bgblitz.com). ```

 Robert-Jan Veldhuizen  writes: ```I guess there's some extra complicating factors which causes the different views: In backgammon, there are also rolls to be considered, not just moves You can evaluate a position with or without a given dice roll (similary: you can evaluate cube and play decisions) Given a certain roll, is determining all valid moves and evaluating their resulting positions a way of looking ahead or not? Personally I agree very much that GNUBG's 0-ply (static) cube evaluation is indeed 0-ply. It seems silly to me to call this 1-ply. The actual position is fed directly into the NN; no lookahead whatsoever. However, when you roll something and then analyse this at GNUBG's 0-ply, one could say that you're looking ahead, since you play all valid moves and evaluate the resulting positions to give the full analysis results. GNUBG's doesn't consider this as looking ahead, probably with the idea that all INDIVIDUAL valid moves are just played then evaluated statically, so 0-ply. But there's something to say to call the whole operation of finding the best move at 0-ply, actually a 1-ply analysis (consisting of multiple 0-ply evaluations?)... Confusing stuff for sure..! ```

 Jordan Lampe  writes: ```When I was a kid and we had computer chess programs, there was no such thing as 0-ply. 1-ply meant that the program looked at each possible move (that's the ply), evaluated the position, and then returned the result (i.e. the best move). 2-ply meant that it looked at each possible move and each possible response, etc. Between backgammon and chess, there is much more reason in backgammon to evaluate a position statically, on its merits alone, as compared to chess where I've never had the experience of asking a computer to say who is winning and by how much (remember I was a kid back then). It seems that nowadays, when you ask a backgammon program to make a move, it does a search of all legal moves ("1-ply") and then evaluates each position statically ("0-ply"). A 1-ply search but a 0-ply evaluation, if you will. When it comes to a doubling decision, the Gnu count is clearly more accurate, because "Snowie 1-ply" doesn't do any lookahead at all when deciding. So, while it's possible to argue that Gnu's count is more accurate, I also think that Snowie set the precedent. Snowie's count isn't horrible, and a whole generation of backgammon players has been confused by Gnu's insistence on the "correct" method. ```

 Jørn Thyssen  writes: ```I don't think it's possible to find a consistent scheme that matches Snowie's way of counting, so the pragmatic solution is just to change gnubg to match Snowie, and forget about finding such a scheme. Perhaps the gnubg developers just have to accept that somebody came up with counting schemes that are now industry standard, and just abide to it :-) I've previously refused to consider changing gnubg, but I'm starting to soften up, and I'll consider suggested that we take the pragmatic solution and change gnubg to follow the same counting scheme as Snowie... To my knowledge this is the solution chosen by the Zbot team; internally counting starts from zero but externally it starts from one. However, I don't think this means that Zare agrees with the numbering used by gnubg :-) ```

 Douglas Zare  writes: ```I don't feel Snowie's conventions are necessarily the most natural. From one perspective, I would prefer to use Snowie's count for checker play decisions and gnu's 0-based count for cube decisions. (A 1-ply checker play search evaluates the moves on 0-ply.) Will we impose that hybrid on Zbot users? Of course not. As far as the users are concerned, Zbot will follow Snowie's convention, at least for evaluations. The point is to communicate. ```

### Programming

Adjusting to a weaker opponent  (Brian Sheppard, July 1997)
Anticomputer positions  (Bill Taylor+, June 1998)
BKG 9.8 vs. Villa  (Raccoon+, Aug 2006)
BKG 9.8 vs. Villa  (Andreas Schneider, June 1992)
BKG beats world champion  (Marty Storer, Sept 1991)
Backgames  (David Montgomery+, June 1998)
Blockading feature  (Sam Pottle+, Feb 1999)
Board encoding for neural network  (Brian Sheppard, Feb 1997)
Bot weaknesses  (Douglas Zare, Mar 2003)
Building and training a neural-net player  (Brian Sheppard, Aug 1998)
How to count plies?  (Chuck Bower+, Jan 2004)
How to count plies?  (tanglebear+, Mar 2003)
Ideas for improving computer play  (David Montgomery, Feb 1994)
Ideas on computer players  (Brian Sheppard, Feb 1997)
Introduction  (Gareth McCaughan, Oct 1994)
Measuring Difficulty  (John Robson+, Feb 2005)
Methods of encoding positions  (Gary Wong, Jan 2001)
N-ply algorithm  (eXtreme Gammon, Jan 2011)
Neural net questions  (Brian Sheppard, Mar 1999)
Pruning the list of moves  (David Montgomery+, Feb 1994)
Search in Trees with Chance Nodes  (Thomas Hauk, Feb 2004)
Source code  (Gary Wong, Dec 1999)
TD-Gammon vs. Robertie  (David Escoffery, June 1992)
Training for different gammon values  (Gerry Tesauro, Feb 1996)
Training neural nets  (Walter Trice, Nov 2000)
Variance reduction in races  (David Montgomery+, Dec 1998)
Variance reduction of rollouts  (Michael J. Zehr+, Aug 1998)
Variance reduction of rollouts  (Jim Williams, June 1997)
What is a "neural net"?  (Gary Wong, Oct 1998)
Writing a backgammon program  (Gary Wong, Jan 1999)