ChessPositionRanking

Assuming you're referring to [0], that's a statistical estimate of valid chess positions (based on clever methods of uniform position sampling + fast validity testing), not valid chess games (based on estimating branching factors for very long games). [0] https://github.com/tromp/ChessPositionRanking

96 bits is not nearly enough, as there are ~4.8 * 10^44 > 2^148 legal chess positions (with side to move/castling/ep info) [1]. Chess Position Ranking provides a 153 bit encoding but it's very slow to decode. If the encoding only needs to work for the set of positions occurring in some database, then there's almost no limit to the number of coding optimizations one can make (until the encoding just becomes an index in the set of all unique db positions). [1] https://github.com/tromp/ChessPositionRanking

> There is no reachable chess position with more than 218 moves. "no more than 218 possible next moves" would be a lot clearer... > By checking all approximately 8.7x10^45 reachable chess positions? That's a large overestimate. https://github.com/tromp/ChessPositionRanking accurately estimates the number of legal chess positions at ~4.8x10^44.

> “No, no,” said God, “it was really tough. More than 10^35 legal positions God should know there are approximately 4.8*10^44 legal positions [1]. > Secondly Ken was predicting that the game of chess was a draw, i.e. that probably a majority of all legal positions, including the starting position, would lead to a draw with perfect play. Only the latter is what the game being drawn means. The majority of legal positions is in fact overwhelmingly to one side's advantage, as is clear from sampling a few dozen random legal positions. [1] https://github.com/tromp/ChessPositionRanking

> For one, gpt-3.5-turbo-instruct rarely suggests illegal moves, even in the late game. This requires “understanding” chess. Here's one way to test whether it really understands chess. Make it play the next move in 1000 random legal positions (in which no side is checkmated yet). Such positions can be generated using the ChessPositionRanking project at [1]. Does it still rarely suggest illegal moves in these totally weird positions, that will be completely unlike any it would have seen in training (and in which the legal move choice is often highly restricted) ? While good for testing legality of next moves, these positions are not so useful for distinguishing their quality, since usually one side already has an overwhelming advantage. [1] https://github.com/tromp/ChessPositionRanking

Peter Österlund wrote the texelutil legality (dis)proving engine that was used in my ChessPositionRanking project [2] to accurately estimate the number of legal chess positions, by analyzing 94903 randomly generated positions that might or might not be legal. [1] https://github.com/peterosterlund2/texel [2] https://github.com/tromp/ChessPositionRanking

Technically speaking, it would require ~ 4.8 * 10^44 pages to cover all legal chess positions [1]. But they're happy to serve utterly illegal positions like https://chess.maxmcd.com/rnbqkbnr/qqqqqqqq/8/8/8/8/QQQQQQQQ/... as well. [1] https://github.com/tromp/ChessPositionRanking

It doesn't really matter, since every position with 24 pieces can change into one with fewer. So you need the sum of all of those values. For a more sophisticated estimation of the number of legal positions, taking into account _true_ legality (a legal position must be reachable by a sequence of legal moves from the starting position, however dumb), see https://github.com/tromp/ChessPositionRanking. You can probably filter their sample by number of pieces to gain pretty accurate estimations for number of 29-piece positions if you wish.

The optimum compression seems to be an index into the list of all legal moves. But one can do better on average, by assuming that moves are not uniformly distributed. Let an engine assign each legal move m some probability p of being played. The worse the move, the lower the probability we assign to it. Then a more optimal code for move m is -log p bits, corresponding to an entropy (expected surprise) of sum -p log p bits for the distribution over legal moves. Related: accurately estimating the number of legal positions of chess [1]. [1] https://github.com/tromp/ChessPositionRanking

Yes, although 1. You'd definitely want to deduplicate positions of identical pieces for even more savings 2. That only handles the case where no pieces have been captured, and the full arithmetic coding would probably need separate "sections" of the integer range for different cases, and the number of sections is also quite high. 3. There's extra nuanced things you might want to handle in the coding, like that pawns can't be on their own back row. That is significantly harder. It looks to me like https://github.com/tromp/ChessPositionRanking has resolved these sorts of issues, but I haven't dug into exactly how.

How to store a legal chess position in log_2(8726713169886222032347729969256422370854716254) ~ 152.6 bits ~ 19.1 bytes using rankings: https://github.com/tromp/ChessPositionRanking But the major point of this project is to allow for random sampling of positions with a decent likelihood of getting a legal one, which allows for accurate estimation of the number of legal positions.

The permutation ranking algorithm described in the article can be generalized to a so-called multinomial ranking, one of several rankings implemented in Haskell [1]. E.g. > let r = multinomialRanking (zip "abc" [1..3]) > size r 60 > unrank r 42 "cbcabc" > rank r "cbcabc" 42 Various types of rankings, together with combinators to build up more complex ones, were implemented as part of the chess position ranking project [2] which aims to rank a subset of all chess positions that includes all legal ones: > let cpr = sideToMoveRanking `composeURI` (caseRanking `composeRI` wArmyStatRanking `composeURI` bArmyStatRanking `composeRI` guardRanking `composeRI` enPassantRanking `composeURI` epOppRanking `composeURI` sandwichRanking `composeRI` opposeRanking `composeURI` pawnRanking `composeURI` castleRanking `composeURI` wA

In late 2013 I came up with the first memory hard Proof-of-Work puzzle, Cuckoo Cycle [1], based on finding fixed-length cycles in random graphs. Recently, custom chips were developed to solve it more efficiently than GPUs can. That probably had more impact than the Binary Lambda Calculus language I designed [2] or the logical rules of Go I co-formulated [3]. Computing the number of Go positions [4] or approximating the number of Chess positions [5] had little impact beyond satisfying my intellectual curiosity. [1] https://github.com/tromp/cuckoo [2] https://tromp.github.io/cl/cl.html [3] https://tromp.github.io/go.html [4] https://tromp.github.io/go/legal.html [5] https://github.com/tromp/ChessPositionRanking#readme