Comparison of Chess Assistant 9 and CQL 3.01

Chess Assistant 9 implements all the features of CQL 3.01, but also adds some new features and graphical extensions. It is interesting to compare the core CQL 3.01 functionality, as defined and implemented by the authors of CQL, and the implementation in Chess Assistant 9. Running the same query on the same game collection in both applications should give identical results. Fortunately that is exactly what happens almost without exception. There are, however, three exceptions that I have run into so far.

Stalemate?

This is the game fraction used for this test:

The query is very simple and searches for a stalemate:

Note that the :pgn and :output are not needed when running this query in Chess Assistant 9. This is the initial position in the game:

Obviously there is no stalemate after after 1. c4 and Chess Assistant 9 sees that and correctly doesn’t find any stalemate position in this game. In order to compare this with the CQL 3.01 implementation found at http://www.rbnn.com/cql/ the game above should be saved to cqleperror.pgn and the query needs to be saved as a CQL file. If it is saved under the name stalemate.cql the following command line will run the query:

The results, which are written to cql-match.pgn look like this:

Notice the {MATCH} after 1. c4. It means that the position after that move matches the query conditions. According to that it should be a stalemate, which isn’t true.

A move or not a move: that is the question

Here is another example where the original CQL implementation and Chess Assistant 9 don’t agree. The following query can be used to show the difference:

This query looks at the first move by each white piece in the game. If the move doesn’t deliver check there is a match. The query was run against the following game as an example. The matches found by CQL 3.01 are shown:

Chess Assistant 9 gives the same result, except it doesn’t find a match in 27. Rd5. Here is what the position looks like before that move:

By giving a match for this position CQL 3.01 counts 27. Rd5 as the first move by the rook on d1. But this rook was on a1 in the initial position, so obviously it has moved, but it was a special move. The rook landed on d1 when white castled on move 15. So the question is if castling should only be counted as a move by the king as CQL 3.01 seems to do? Or should it be counted as the first move for both the king and the rook as Chess Assistant 9 does? It certainly looks odd to see 27. Rd5 counted as the first move by the rook, so Chess Assistant seems to handle this case as chessplayers would expect.

Matchcount confusion

This query, which can be found in the CQL 3.01 documentation, searches for games where the same piece delivers at least 30 checks.

Both CQL 3.01 and Chess Assistant 9 mark all positions in the game where the piece in question gives check to the black king.

The following query is similar, but the position list specifies a sequence. In order for a position to match, the tagged piece must make the next move and it must be a non-checking move.

By comparision with the previous query this one should be expected to return games where the same piece makes at least 30 non-checking moves in a game. That is actually what both Chess Assistant 9 and CQL 3.01 seem to do, but there is a difference when you check the marked positions in the matching games. CQL 3.01 marks all positions in the games where any white pieces makes a non-checking move. In other words, the only positions (with white to move) that are not marked is where a white piece delivers check on the next move. Chess Assistant 9, on the other hand, restricts the marks to the piece that actually makes the 30 moves without checking the black king. The difference can be seen from this game fraction where only the white queen made more than 30 non-checking moves. First the output from CQL 3.01:

Any position followed by a non-checking white move is marked. Chess Assistant 9, however, correctly only marks moves by the white queen:

Conclusion

The implementation of CQL in Chess Assistant 9 seems to be very good. In cases where its interpretation of CQL does not agree with the original implementation of CQL 3.01, Chess Assistant seems to have chosen the correct or at least the more logical way to interpret CQL.