# attacks and attackedby

The `attacks` and `attacksby` infix filters are used to determine the squares attacked by a piece or set of pieces. Each of these filters two set filters as arguments , left and right:
```  left attacks right
left attackedby right
```
The `attacks` filter matches a position if some piece on the set of squares represented by left attacks some square in the set of squares represented by right.

The `attackedby` filter matches a position if some square in the set of squares represented by left is attacked by some piece in the set of squares represented by right.

Thus,

`left attacks right`
matches a position if and only if
`right attackedby left`
matches that position.

Here are some specific examples

```      A attacks k
Q attackedby n
. attackedby k```

## The sets represented by attacks and attackedby

Each of `attacks` and `attackedby` are set filters.
```  left attacks right
```
represents the set of squares in left on which is a piece that attacks some square in right

`  left attackedby right`
represents the set of squares in left that are attacked by a piece on some square in right

For example, black is in double check if

`    A attacks k>1`
matches the position. That is because
`A attacks k`
represents the set of white pieces attacking the black king. This set is `>1 ` if an only if it has more then one element, that is, if there are at least two pieces in it.

Similarly,

`. attackedby k`
represents the set of squares adjacent to the black King.

In a pure mate, we want each empty square around the black king to be attacked at most once. We can check this like this:

```btm mate
square all FlightSquare in _ attackedby k
A attacks FlightSquare<=1```
Here, `_ attackedby k` represents the set of empty squares adjacent to the black king.

### More precise definition of 'attack'

We say a piece x on a particular square attacks a square t in a position if a King of the opposite color of x on the square t would be in check from x.

In particular, a piece can attack a square even if the piece could not move to that square. For example:

• if there is a white pawn on `d4`, then that pawn attacks exactly the squares `c5` and `e5`, no matter what other pieces are on the board or whose move it is. Likewise, a black pawn on `g7` attacks exactly the squares `h6` and `f6`, even if black is in check, or it is white's turn, or there are black pieces on `h6` and `f6`.
• a pinned piece can attack a square even if moving to that square would be illegal due to the pin. A black knight on `b2` attacks `c4`, even if the knight is pinned.

### precedence

The `attacks` and `attackedby` have the same precedence (left-to-right). They have stronger precedence than the set operations `&` and `|`. Hence,
`A attacks k | n`
is parsed as
`(A attacks k) | n`
and represents the set of white checking pieces and black knights. To get the white pieces attacking either the black king or the black knight, use:
`	A attacks (k|n)`

As usual, we strongly recommend using parentheses to clarify such expressions if you have any doubt of the precedence.

Note that because `attacks` and `attackedby` have stronger precedence than the arithmetic comparison operators, something like

`A attacks k>1`
is the same as
`(A attacks k)>1`
which is what is expected.

# Examples

In a mirror mate the mated king is surrounded by empty squares, as in the following position from a study by Arestov:
Arestov 2013, after 10. h8=N#
(found from CQL file: mirrormate.cql)

This was found by the CQL code below:

``` btm mate
_ attackedby k == 8```

In the above fragment, ` _ attackedby k` is the set of empty squares attacked by the black king. Equivalently, this is the set of empty squares adjacent to the black king. Checking if set is `== 8` is the same as checking that the number of elements in the set equals 8, due to the rules for conversion of sets to numbers. Thus, that filter is the same as

`  #{ _ attackedby k} == 8`

The diagram below shows a position where white mates with a lone knight:

Bazlov 2008
(found from CQL file: loneknightmate.cql)

In the CQL file, the line `N attacks k` assures that the black king is under check from a white knight.

` A attacks k`
will be true in a position in which Black is in check. The associated set will be empty if the black king is not in check, and will contain the set of checking pieces otherwise.
` not A attacks k`
will be true in a position in which the black king is not in check.
` not A attacks (_ attackedby k)`
will be true in a position in which no empty square in the black king's field is attacked by a white piece.
` A attacks .>= 40`
will be true when white is attacking at least 40 squares.

The `attacks` filter is used throughout the CQL examples. It is used extensively all the variations of pure mate computation, such as puremate.cql, modelmate.cql, modelstalemate.cql, idealmate.cql and so on. It is also used in clearance-delayed.cql to check whether a piece attacks a particular square.

The `attackedby` filter is likewise used in the mate related examples above, notably to compute the king's field:

`KingsField= . attackby k`
It is also used in wurzburg-plachutta.cql to loop over all empty squares that are attacked by two different pieces:
```	square CriticalSquare in ( attackedby X)&( attackedby Y)
....```