For example, consider the following filter, which is equal to the number of white pieces in the previous position:

parent:#A

If the current position is the initial position, then this parent filter would not match the position (since the initial position has not parent). Suppose the current position is the initial position.

	5==parent:#A

will be true only if the following two conditions are satisfied:

1. the current position is not the initial position
2. the previous position has exactly 5 white pieces in it.

Thus, if the current position is the initial position, each of the following three filters are always false (never match):

	5 == parent:#A
        5<parent:#A
        5>parent:#A

However,

        5 != parent:#A

	not {5 == parent:#A}

Conversions of set operands to numbers

Thus,

A==3

{#A}==3

Similarly,

	A attacks k>1

	#{A attacks k}>1

Conversion of position operands to numbers

	{find check}<find move promote N

<
	{find check} : positionid<{find move promote N} : positionid

The value of the find move promote N filter is the next position that is a knight underpromotion.

When these two positions are compared, they are converted into their numeric positionid values. The positionid filter has as value the position id of the current position. Thus, {find check} : positionid gives the positionid of the position of the next check, using the : operator to evaluate positionid using another current position. Likewise, {find move promote N} : positionid is the positionid of the next knight underpromotion.

Conversions of position operands are most commonly used in the body of the echo filter. Typically, an echo filter might begin something like this:

	echo (source target) {
	source<target
	...
	}

This idiom can be used to ensure that the target position is a descendant of the source position (if variations is not set); or simply to make sure that the same pair of positions is only evaluated once in the body of the echo.

comparing set filters using ==

For example, if x is a set variable, then

	x==.

	#x==64

	x==64

The numeric value of a comparison operator

For example, to check if the number of white pawns is between at least 4 and smaller than 7 in a position, we can use

	4<=(#P<7)

That is because, if the number of white pawns is >= 7, then the #P<7 filter will not match, so neither neither will the 4<=... filter (because relational filters do not match if one their arguments does not match).

On the other hand, if the number of white pawns is smaller than 7, then #P<7 will match and will have value equal to #P. In this case, the whole filter will match if 4<=#P matches, which is what we want.

In fact, because relational operators are right associative, and because sets compared with numbers are converted to their cardinality, the above filter is equivalent to the terse:

      4<=P<7

Such ternary relational operator notation is common in mathematics: CQL is one of the few (only?) languages we are aware of supporting it.

The numeric value of comparison operators is often exploited in echo filters that are sorted. Sometimes we want to sort an echo by the distance between the source and the target:

	sort
	echo (source target){
	...
	distance(source target)>= 5}

The value of the body of the echo is equal to distance(source target) whenever that distance is at least 5 (and the other requirements of the echo body also match). If the distance is not at least 5, the body does not match.

When a named filter requires a numeric argument, the filter normally has higher precedence than the binary comparison operators. Thus,

	abs x<3

	{abs x}<3

        abs {x<3}

However, because sort can take a set filter as argument,

		 
      sort #A>= 10
         ≡
      sort (#A>= 10)
         ≡
      sort A>= 10
         ≡
       sort (A>= 10)

Relational operators with string arguments

Relational operators can have string filter arguments. Strings are compared in lexicographic order by the ASCII value of their characters, so that for example

  "A">"a"
  "Ab">"A"
  ""<"A"

Relational operators have string values just like the case for for numeric values. Therefore, they can be chained just like for numeric values.

Thus, to check that a character X is lowercase, one could use

	     
 "a"<=X<="z"

Examples

Q==2
q==2
[Aa]==6

Similarly, q==2 is true if the number of black queens on the board is equal to 2.

Finally, [Aa]==6 is true if the total number of white (A) or black (a) pieces is equal to 6. If so, the material must be KQQkqq.

This file finds the following position:

In the position it is black to move, and because of this, black loses. If the position were white to move, black would draw. This position itself was found by computer; the study is the first ever composed using a six-piece tablebase.