# `&`

operator

The `&`

filter has the syntax:
left&right

where

and *left*

are each filters. The *right*

and *left*

arguments must each be set filters or each be positionfilters.
*right*

## `&`

operator as set intersection

If the *left*

and *right*

arguments to the `&`

filter are each set filters, then the `&`

filter is itself a set filter whose
value is the intersection of the sets of squares represented by its arguments.
For example,

pin&{R attacks k}

Is the set of squares on which a pinned white rook attacks the black king. The

argument to the *left*`&`

filter is pin whose value is the set of squares on which there is a pinned piece. The

argumnet to the *right*`&`

filter is `{R attacks k}`

, whose value is the set of squares
on which there is a white rook which attacks the black king. The value of the `&`

filter is the intersection of these two sets.

## positional intersection: `&`

used to compare two positions

If the

and *left*

arguments to the *right*`&`

filter are each position filters, then the value of the `&`

filter
is the *positional intersection* of the positions represented by these arguments.
In this case we call the `&`

filter a *positional intersection*

The positional intersection of two positions is the set of squares on which the two positions have the same type and color of piece.

For example, consider the PGN file representing moves beginning from the start position of the game of chess:

1. e4 e5 2. Nf3 Nc6

Now, after reading this game, let

x= position 0 y= position 2

Thus, `x`

is the initial position and `y`

is the position after `1. e4 e5`

.

Then `x&y`

is the set of squares on which `x`

and `y`

have the same contents. This is the 60 squares represented by:

~[e2,e4,e7,e5]

That is because on each of these 4 squares, `x`

and `y`

differ. The contents of `x`

on the square `e2`

for example is a white pawn; but
the contents of `y`

on that square is empty, so they differ.

More generally, suppose `X`

and `Y`

are any variables that hold positions. Then then

```
X&Y
≡
square z in .
X:colortype z == Y:colortype z
```

That is because `colortype z`

is a number expressing the type and color of the contents of the square `z`

in the current position.
Thus, `X:colortype z`

is a number expressing the type and color of the contents of the square `z`

in the position `X`

(and likewise
for `Y:colortype z`

).

The square filter therefore gives the set of squares in which `X`

and `Y`

have the same contents, that is, `X&Y`

# Examples

The `&`

operator as set intersection is used throughout the CQL examples.

The positional `&`

operator is most often used with the echo filter to compare positions. For example, in zugzwang1.cql , the filter

source&target==.

is used to check whether the variables `source`

and `target`

represent the same board position. This works because the . filter rerepresentes the set of all squares, so the expression above matches the position when the `source`

and `target`

position have the same board contents (although not necessarily the same side to move).

The `&`

filter is also used in contexts like movedblackpieceecho.cql where it is necessary to count the number of squares on which two positions differ. There we see the code:

mismatches= ~(source&target) mismatches==2This sets the variable

`mismatches`

to be the set of squares on which the positions `source`

and `target`

differ, and then requires that this set contains exactly `2`

squares.
The next line of the file movedblackpieceecho.cql sets the piece variable named `Mover`

the single black piece (if any) on that intersection:

piece Mover=a&mismatchesNote that this use of

`&`

is *not*a positional ampersand. This use is just the usual set intersection, since both

`a`

and
`mismatches`

are set filters.