# Canonical Theme Specification Encyclopedia (659 Themes)

> **Single Source of Truth**: Auto-generated from `mate2/src/pattern_dsl/specs.rs`.

> **Interactive Web Specification**: [https://themachess.com/THEMES.html](https://themachess.com/THEMES.html)

> **Language Specification & Reference**: [THEMA.md](THEMA.md) | [THEMA.html](THEMA.html)


## Table of Contents

- [01. Interferences, Obstructions & Line Clearances (112)](#01-interferences-obstructions--line-clearances)
- [02. Pinning, Half-Pins & Unpinning Dynamics (100)](#02-pinning-half-pins--unpinning-dynamics)
- [03. Batteries & Discovered Checks (40)](#03-batteries--discovered-checks)
- [04. Cyclic Systems & Grandmaster Complex Cycles (84)](#04-cyclic-systems--grandmaster-complex-cycles)
- [05. Multi-Threat Separation & Named Try-Play Systems (71)](#05-multi-threat-separation--named-try-play-systems)
- [06. Phase Changes, Transferences & Changed Play (67)](#06-phase-changes-transferences--changed-play)
- [07. Black & White Corrections (18)](#07-black--white-corrections)
- [08. Checks, Cross-Checks & Counter-Attacks (15)](#08-checks-cross-checks--counter-attacks)
- [09. King Flights & Board Geometry (37)](#09-king-flights--board-geometry)
- [10. Piece Wheels, Crosses & Geometric Stars (16)](#10-piece-wheels-crosses--geometric-stars)
- [11. Special Rules, Promotions & Tasks (14)](#11-special-rules-promotions--tasks)
- [12. Mating Net Types & Aesthetic Properties (13)](#12-mating-net-types--aesthetic-properties)
- [13. Tactical Motifs, Sacrifices & Maneuvers (38)](#13-tactical-motifs-sacrifices--maneuvers)
- [14. Stipulations, Key Types & Piece Economy (34)](#14-stipulations-key-types--piece-economy)

---

## 01. Interferences, Obstructions & Line Clearances

*Mutual interferences (Grimshaw, Novotny, Plachutta), linear obstructions, line clearances (Bristol), bivalve, valve, and critical maneuvers.*

### Grimshaw
**Enum**: `NamedTheme::Grimshaw` · *Alias*: Mutual Interference

Mutual interference between two Black pieces with different line movements (typically Rook and Bishop) on the same intersection square.

```thema
key [A B]
where {a.role, b.role} == {'R', 'B'}, !a.capture,
  mutual_obstruction(a, b, A, B)
with -match_mate_count
subsumes SelfInterference
story "Grimshaw: Key 1.{K}!{threat_clause} causes mutual
  interference on {a.to}: 1...{a} allows 2.{A}# vs 1...{b}
  allows 2.{B}#"
---
set [A B]
where {a.role, b.role} == {'R', 'B'}, !a.capture,
  mutual_obstruction(a, b, A, B)
with -match_mate_count
subsumes SelfInterference
story "Set Grimshaw: Mutual interference on intersection
  square {a.to} in set play: 1...{a} allows 2.{A}#
  vs 1...{b} allows 2.{B}#"
```

### Novotny
**Enum**: `NamedTheme::Novotny` · *Alias*: Novotny Interference

White key sacrifices on the intersection square of two Black linear pieces (R and B); each capture interferes with the other defending piece.

```thema
def [a:x@K b:x@K]
key K [A B]
where {a.role, b.role} == {'R', 'B'},
  a.mutually_blocks(b, A, B)
with -match_mate_count
subsumes ActiveSacrifice
story "Novotny: Key 1.{K}!{threat_clause} cuts lines
  of communication on {K.to}: 1...{a} allows 2.{A}#
  vs 1...{b} allows 2.{B}#"
```

### Plachutta
**Enum**: `NamedTheme::Plachutta`

Two similar Black line pieces (both Rook-like or both Bishop-like) defend to the same square with mutual interference.

```thema
any [A* B*]
where same_square(a, b), like_sliders(a, b),
  a.from != b.from, (!a.capture || !b.capture),
  (a.mutually_blocks(b, A, B)
    || collinear(a.from, b.from, a.to))
with -match_mate_count
subsumes DefencesOnSameSquare, Holzhausen, Laitinen
story "Plachutta on {a.to}: Key 1.{K}!{threat_clause}
  Mutual interference between like-moving Black pieces
  on {a.to}: 1...{a} allows 2.{A}#; 1...{b} allows 2.{B}#"
```

### Würzburg-Plachutta
**Enum**: `NamedTheme::WuerzburgPlachutta` · *Alias*: Wuerzburg Plachutta

Two similar Black line pieces defend to the same square by capturing with mutual interference.

```thema
def [a:x b:x]
key [A B]
where same_square(a, b), a.from != b.from,
  like_sliders(a, b),
  (!collinear(a.from, b.from, a.to)
    || (between(a.to, a.from, b.from)
    && (collinear(a.from, a.to, A.to)
    || collinear(b.from, b.to, B.to))))
subsumes DefencesOnSameSquare, Holzhausen, Laitinen
story "Würzburg-Plachutta on {a.to}:
  Key 1.{K}!{threat_clause} Mutual interference
  between like-moving Black pieces capturing on {a.to}:
  1...{a} allows 2.{A}#; 1...{b} allows 2.{B}#"
```

### White Grimshaw
**Enum**: `NamedTheme::WhiteGrimshaw`

Mutual interference between two White pieces (Rook and Bishop) on the same square across tries, try and key, or mating moves.

```thema
try Tr1
try Tr2
where same_square(Tr1, Tr2), unlike_sliders(Tr1, Tr2),
  Tr1.from != Tr2.from
with -single_refutation -sparse_mates -few_replies
  -match_threat_count
story "White Grimshaw: White Rook and Bishop mutually
  interfere on {Tr1.to} across tries 1.{Tr1}?
  and 1.{Tr2}?"
---
try Tr
key K
where same_square(Tr, K), unlike_sliders(Tr, K),
  Tr.from != K.from
with -single_refutation -sparse_mates -few_replies
  -match_threat_count
story "White Grimshaw: White Rook and Bishop mutually
  interfere on {Tr.to} across try 1.{Tr}? and key 1.{K}!"
---
key [A B]
where same_square(A, B), unlike_sliders(A, B),
  A.from != B.from
story "White Grimshaw: Key 1.{K}!{threat_clause} leads
  to mutual interference between the White Rook and
  Bishop on {A.to} delivering checkmate (1...{a} 2.{A}#
  vs 1...{b} 2.{B}#)."
```

### Anti-Bristol
**Enum**: `NamedTheme::AntiBristol` · *Alias*: Black Anti-Bristol

A piece moves along a line toward another friendly piece, closing its line of action.

```thema
key K
where K.anti_bristol
story "Anti-Bristol: Key 1.{K}!{threat_clause} moves
  along the line toward a friendly piece, closing its line
  of action."
---
key [A B]
where same_square(a, b), a.from != b.from, !a.capture,
  (a, b).slider, collinear(a.from, a.to, b.from),
  between(a.to, a.from, b.from),
  a.mutually_blocks(b, A, B)
story "Anti-Bristol: Key 1.{K}!{threat_clause} induces
  Black sliders to move toward each other onto {a.to},
  closing each other's line: 1...{a} 2.{A}#
  vs 1...{b} 2.{B}#."
```

### Bristol Clearance
**Enum**: `NamedTheme::BristolClearance` · *Alias*: Bristol

A line-moving piece moves along a line away from another friendly piece to clear the line.

```thema
key K [A]
where K.clears_line_for(A)
story "Bristol line clearance: Key 1.{K}!{threat_clause}
  glides along the line away from the friendly
  {A.role_name}, clearing the way for 2.{A}#."
---
key K (A)
where K.clears_line_for(A)
story "Bristol line clearance: Key 1.{K}! glides
  along the line away from the friendly {A.role_name},
  clearing the way for threat 2.{A}#."
```

### Goethart
**Enum**: `NamedTheme::Goethart` · *Alias*: Goethart unpin

Black defense indirectly unpins a White piece by closing the pin line, or White battery mate unpins a Black piece after a Black interference/unpin.

```thema
key [A]
where a.unpins(A),
  (between(a.to, A.from, WK) || a.closes_line(WK)
    || a.closes_line()),
  !collinear(a.from, A.from, WK)
story "Goethart unpinning: Key 1.{K}!{threat_clause}.
  Defense 1...{a} indirectly unpins White while closing
  a line, allowing 2.{A}#."
---
key [A]
where A.unpins(BK),
  (a.closes_line() || a.unpins(A) || (!A.fires_battery
    && a.self_block))
subsumes Mari
story "Goethart unpinning: Key 1.{K}!{threat_clause}.
  Defense 1...{a} obstructs a pinned Black piece,
  allowing 2.{A}# to unpin it and deliver mate."
```

### Organ pipes
**Enum**: `NamedTheme::OrganPipes`

Mutual interference among four line pieces (two Rooks and two Bishops) on adjacent files or ranks.

```thema
def [a:R b:B c:R d:B]
any [A B C D]
where distinct(a.from, b.from, c.from, d.from),
  (same(a.from.rank, b.from.rank, c.from.rank,
    d.from.rank) || same(a.from.file, b.from.file,
    c.from.file, d.from.file)),
  a.mutually_blocks(b, A, B), c.mutually_blocks(d, C, D)
story "Organ Pipes: Key 1.{K}!{threat_clause}. Fourfold
  mutual interference between two Rooks and two Bishops:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#,
  1...{d} 2.{D}#."
```

### Bivalve
**Enum**: `NamedTheme::Bivalve`

A move opens one line and closes another line of the same color.

```thema
key [A]
where a.bivalve(A)
with -match_mate_count
subsumes Valve
story "Bivalve: Key 1.{K}!{threat_clause}.
  Defense 1...{a} opens one line while closing another,
  enabling checkmate 2.{A}#."
---
key [A B]
where same_piece(a, b), a.to != b.to, A != B, a.valve(A),
  b.valve(B)
with -match_mate_count
subsumes Valve
story "Bivalve: Key 1.{K}!{threat_clause}. Defenses
  1...{a} and 1...{b} by the same piece open a line while
  closing two different lines, enabling checkmates 2.{A}#
  and 2.{B}#."
```

### Valve
**Enum**: `NamedTheme::Valve`

A Black move opens a line while closing another line.

```thema
key K [A]
where a.valve(A) || a.bivalve(A)
with -match_mate_count
story "Valve: Defense 1...{a} opens one line while closing
  another, enabling checkmate 2.{A}#."
---
set [A]
where a.valve(A) || a.bivalve(A)
with -match_mate_count
story "Valve: Defense 1...{a} opens one line while closing
  another, enabling checkmate 2.{A}#."
```

### Critical move
**Enum**: `NamedTheme::CriticalMove`

A piece moves across a critical square so that another piece can subsequently occupy or cross that square.

```thema
key K [A]
where K.slider,
  (K.crosses(a) && a.closes_line() && !(A.from == K.to
    && A.recaptures(a)) && !between(a.from, K.to, A.to))
    || (K.crosses(A) && A.from != K.to
    && (collinear(K.from, K.to, A.from)
    || (collinear(K.from, K.to, BK)
    && between(A.to, K.to, BK) && A.slider)))
story "Critical move: Key 1.{K}!{threat_clause} crosses
  a critical square, enabling 2.{A}# against 1...{a}."
---
key [A B]
where same_piece(a, b), a.slider, a.crosses(A),
  b.crosses(B)
story "Critical move: Key 1.{K}!{threat_clause} compels
  Black's {a.piece} to cross critical squares ({A.to},
  {B.to}), enabling 1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
any [A]
where a.slider, a.crosses(A)
story "Critical move: Black's {a.piece} move 1...{a}
  crosses the critical square {A.to}, enabling 2.{A}#."
```

### Clearance
**Enum**: `NamedTheme::Clearance` · *Alias*: Line clearance

A piece vacates a line of action (or moves along a line) so that another friendly piece can traverse that cleared line to deliver checkmate.

```thema
key K [A]
where A.from != K.to, K.from != A.to,
  (A.crosses(K.from) || K.clears_line_for(A))
story "Line clearance: Key 1.{K}!{threat_clause} vacates
  {K.from}, clearing the line of action for 2.{A}#
  against 1...{a}."
---
key K (A)
where A.from != K.to, K.from != A.to,
  (A.crosses(K.from) || K.clears_line_for(A))
with -match_threat_count
story "Line clearance: Key 1.{K}! vacates {K.from},
  clearing the line of action for threat 2.{A}#."
---
key K [A@K.from]
where A.from != K.to
story "Square clearance: Key 1.{K}!{threat_clause}
  vacates {K.from}, allowing 2.{A}# to occupy {K.from}
  against 1...{a}."
---
key K (A@K.from)
where A.from != K.to
with -match_threat_count
story "Square clearance: Key 1.{K}! vacates {K.from},
  allowing threat 2.{A}# to occupy {K.from}."
```

### Gate opening
**Enum**: `NamedTheme::GateOpening`

A piece moves off a line to open access (open the gate) for a line-piece behind it.

```thema
key K [A]
where A.from != K.to, K.from != A.to, A.crosses(K.from)
story "Gate opening: Key 1.{K}!{threat_clause} opens
  a gate through White's lines, enabling checkmate 2.{A}#
  against 1...{a}."
```

### White interference
**Enum**: `NamedTheme::WhiteInterference`

White tries fail because the try piece interferes with the line of another friendly White piece needed for the mate, which the key avoids.

```thema
try Tr1 [! _]
try Tr2 [_ !]
key K [A B]
where between(Tr1.to, A.from, A.to),
  between(Tr2.to, B.from, B.to)
with -match_threat_count -match_mate_count
  -capture_try_piece -refutation_is_check
  -single_refutation
story "White interference: Tries 1.{Tr1}? (refuted
  by 1...{a}!) and 1.{Tr2}? (refuted by 1...{b}!) fail
  by interfering with White's own lines for 2.{A}# and
  2.{B}#, whereas Key 1.{K}!{threat_clause} keeps those
  lines clear."
---
try Tr1 [!]
try Tr2 [_]
key K [A]
where Tr1.to == Tr2.to, Tr1.from != Tr2.from,
  A.from == Tr2.from, between(Tr1.to, A.from, A.to)
with -match_threat_count -match_mate_count
  -capture_try_piece -refutation_is_check
  -single_refutation -sparse_mates -few_replies
story "White interference: Tries 1.{Tr1}? and 1.{Tr2}?
  intersect on {Tr1.to}, interfering with 2.{A}# against
  1...{a}; Key 1.{K}!{threat_clause} keeps the line open."
```

### Anti-critical
**Enum**: `NamedTheme::AntiCritical`

A move that deliberately avoids or crosses a critical square to prevent an interference.

```thema
key K [A]
where K.slider,
  !(A.from == K.to && A.recaptures(a)
    && !A.fires_battery),
  !between(a.from, K.to, A.to),
  ((collinear(K.from, K.to, A.to)
    && between(a.to, K.from, A.to)
    && !between(a.to, K.to, A.to) && a.to != K.to
    && a.closes_line()) || (!K.capture
    && between(a.to, K.from, K.to) && a.role != 'K'
    && ((A.to == a.to && (distance(K.to, a.to) >= 2
    || A.fires_battery)) || a.closes_line()))
    || (!K.capture && between(A.to, K.from, K.to)
    && A.from != K.to && a.to == K.to))
story "Anti-critical move: Key 1.{K}!{threat_clause}
  crosses the critical square {a.to}, enabling 2.{A}#
  against 1...{a}."
---
key K (A*) [A]
where K.slider,
  !(A.from == K.to && A.recaptures(a)
    && !A.fires_battery),
  !between(a.from, K.to, A.to),
  ((collinear(K.from, K.to, A.to)
    && between(a.to, K.from, A.to)
    && !between(a.to, K.to, A.to) && a.to != K.to
    && a.closes_line()) || (!K.capture
    && between(a.to, K.from, K.to) && a.role != 'K'
    && ((A.to == a.to && (distance(K.to, a.to) >= 2
    || A.fires_battery)) || a.closes_line()))
    || (!K.capture && between(A.to, K.from, K.to)
    && A.from != K.to && a.to == K.to))
with -match_threat_count
story "Anti-critical move: Key 1.{K}!{threat_clause}
  crosses the critical square {a.to}, enabling 2.{A}#
  against 1...{a}."
```

### Line closure
**Enum**: `NamedTheme::LineClosure`

A move closes a line of action of an opponent or friendly piece.

```thema
key K [A]
where a.closes_line() || a.closes_line(WK)
    || a.obstructs(A)
story "Line closure: Key 1.{K}!{threat_clause}. Defense
  1...{a} closes a guard line, enabling checkmate 2.{A}#."
```

### Levman
**Enum**: `NamedTheme::Levman` · *Alias*: Levman theme

Two Black pieces move to the same square to parry the threat (closing a White threat line), each introducing a distinct fatal weakness (unpinning, self-pinning, interference, or unguard) exploited by distinct mates.

```thema
key K (X) [A B]
where !a.capture, same_square(a, b), a.from != b.from,
  a.role != b.role, A != B,
  (!A.recaptures(a) || !B.recaptures(b)),
  (a.unpins(A) || b.unpins(B) || a.self_pins_for(A)
    || b.self_pins_for(B) || (a.role == 'N'
    && a.unguards(A)) || (b.role == 'N' && b.unguards(B))
    || ((a.interferes_for(A) || b.interferes_for(B)
    || a.closes_line() || b.closes_line())
    && (a.opens_line(WK) || b.opens_line(WK)
    || a.opens_line() || b.opens_line() || (a.slider
    && b.slider))))
with -match_threat_count -match_mate_count
story "Levman theme: Key 1.{K}! (threat 2.{X}#).
  Defenses 1...{a} and 1...{b} on {a.to} parry the threat
  and allow distinct mates 2.{A}# and 2.{B}#."
```

### Turton
**Enum**: `NamedTheme::Turton` · *Alias*: Turton doubling

A line piece moves along a line past an intersection square, followed by another line piece onto that line in the opposite direction.

```thema
key K [A*]
where K.slider, A.slider, K.along(A), K.crosses(A),
  A.from != K.to
with -match_mate_count
subsumes CriticalMove
story "Turton doubling: Key 1.{K}!{threat_clause} clears
  the line past the critical square, allowing 2.{A}#
  to follow."
---
key K (A*)
where K.slider, A.slider, K.along(A), K.crosses(A),
  A.from != K.to
with -match_threat_count
subsumes CriticalMove
story "Turton doubling: Key 1.{K}! clears the line past
  the critical square to threaten 2.{A}#."
```

### Indian
**Enum**: `NamedTheme::Indian` · *Alias*: Indian theme

A White piece crosses a critical square and is then intercepted by a friendly piece to prevent stalemate, later discovering mate.

```thema
key K [A]
where A.from == K.to, A.fires_battery
subsumes BatteryCreation, BatteryPlay
story "Indian theme: Key 1.{K}!{threat_clause} crosses
  the critical square to mask the line, averting stalemate
  and preparing 2.{A}#."
```

### Pickabish
**Enum**: `NamedTheme::Pickabish` · *Alias*: Pickabish theme

Mutual interference between a Pawn and a Bishop on the same square.

```thema
def [a:P b:B]
key [A B]
where same_square(a, b), !a.is_promotion, !(a, b).capture
subsumes DefencesOnSameSquare, Laitinen
story "Pickabish: Key 1.{K}!{threat_clause} induces mutual
  interference between a Pawn and a Bishop on {a.to}:
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Interference
**Enum**: `NamedTheme::Interference`

A piece moves onto a line of action of another piece, cutting off its guard or power.

```thema
key [A]
where a.interferes_for(A)
story "Interference: Key 1.{K}!{threat_clause} provokes
  defense 1...{a} which interrupts a vital defensive line,
  conceding checkmate 2.{A}#."
```

### Line opening
**Enum**: `NamedTheme::LineOpening`

A piece moves off a line, opening it for an attacking piece.

```thema
key [A:Q|R|B]
where a.role != 'K', !collinear(A.from, a.from, a.to),
  (between(a.from, A.from, BK)
    || between(a.from, A.from, A.to)
    || between(a.from, A.to, BK))
with -match_mate_count
story "Line opening: Defense 1...{a} opens an attack line
  for White checkmate 2.{A}#."
---
key K [A]
where a.opens_line(WK) || (K.opens_line()
    && (between(K.from, A.from, A.to)
    || between(K.from, A.from, BK) || A.fires_battery))
with -match_mate_count
story "Line opening: Move 1.{K} features line-opening play
  (1...{a} 2.{A}#)."
```

### Self-interference
**Enum**: `NamedTheme::SelfInterference`

A Black defending move obstructs the line of another Black defending piece.

```thema
key K [A]
where a.interferes_for(A) || (a.closes_line()
    && !(a.to == A.to && !a.capture)
    && (K.threat_count > 0 || (A.mate_count == 1
    && a.closes_line(A.to)
    && !collinear(a.from, a.to, A.to))
    || a.closes_line(WK))) || (K.threat_count > 0
    && A.mate_count == 1 && a.obstructs(A))
with -match_mate_count
story "Self-interference: Defense 1...{a} interferes with
  a friendly defensive line, conceding 2.{A}#."
---
set [A]
where a.closes_line(A.to) && distance(A.from, A.to) >= 2
    && a.to != A.to && !collinear(a.from, a.to, A.to)
with -match_mate_count
story "Self-interference: Defense 1...{a} interferes with
  a friendly defensive line, conceding 2.{A}#."
```

### Ovchinnikov
**Enum**: `NamedTheme::Ovchinnikov`

Defenses simultaneously open a White line and close a Black line.

```thema
key K [A]
where a.role != 'K', !a.capture, !A.recaptures(a),
  A.from != K.to, a.opens_line(WK), a.closes_line(),
  (K.threat_count > 0 || a.closes_line(A.to))
subsumes LineClosure, SelfInterference
story "Ovchinnikov: Key 1.{K}!{threat_clause} forces
  defense 1...{a} which opens a White line and closes
  a Black line, met by checkmate 2.{A}#."
```

### Square clearance
**Enum**: `NamedTheme::SquareClearance`

A piece moves away from a square so that another piece of the same color can occupy it to mate.

```thema
key K [A@K.from]
where A.from != K.to
subsumes Clearance
story "Square clearance: Key 1.{K}!{threat_clause}
  vacates a vital square, allowing 2.{A}# to deliver mate
  against 1...{a}."
---
key K (A@K.from)
where A.from != K.to
subsumes Clearance
story "Square clearance: Key 1.{K}! vacates {K.from},
  allowing threat 2.{A}# to occupy that square."
```

### Anti-Levman
**Enum**: `NamedTheme::AntiLevman`

The mating move simultaneously unmasks a White line toward BK and closes another White line toward BK.

```thema
key [A]
where a.anti_levman(A)
story "Anti-Levman: Key 1.{K}!{threat_clause} answers
  1...{a} with 2.{A}#, unmasking one White line while
  closing another."
```

### Anti-Novotny
**Enum**: `NamedTheme::AntiNovotny`

A defense that prevents or parries a Novotny interference sacrifice.

```thema
def [a@K.from b@K.from]
key K [A B]
where a.role in {'R', 'Q'}, b.role in {'B', 'Q'}
subsumes BlackUmnov, DefencesOnSameSquare, Laitinen
story "Anti-Novotny: Key 1.{K}!{threat_clause}
  answers defenses preventing Novotny interference:
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Pericritical
**Enum**: `NamedTheme::Pericritical`

A piece takes an indirect two-step detour (K.from -> K.to -> A.to) around a critical line/square after a try along the alternate route (K.from -> T.to toward A.to) fails.

```thema
try T (X?)
key K (Y?) [A]
where same_piece(T, K), K.to == A.from, T.to != K.to,
  (T.threat_count == 0 || X != A),
  (T.threat_count != 1 || K.threat_count != 1 || X == Y),
  !collinear(K.from, K.to, T.to),
  !collinear(K.from, T.to, A.to),
  !collinear(K.from, K.to, A.to),
  !collinear(T.to, K.to, A.to), collinear(T.to, A.to),
  T.threat_count <= 1, K.threat_count > 0,
  (distance(K.from, K.to) > 1 || distance(K.to, A.to) > 1
    || distance(T.to, A.to) > 1)
story "Pericritical move: After try 1.{T}? fails,
  Key 1.{K}!{threat_clause} takes a pericritical detour
  to deliver 1...{a} 2.{A}#."
```

### Anti-Grimshaw
**Enum**: `NamedTheme::AntiGrimshaw`

A defense that parries or prevents a Grimshaw mutual interference.

```thema
try [! _]
try [_ !]
key K
where same_square(a, b), {a.role, b.role} == {'R', 'B'}
story "Anti-Grimshaw: Key 1.{K}!{threat_clause} resolves
  play where defenses deliberately prevent a Grimshaw
  mutual interference."
```

### Isaev
**Enum**: `NamedTheme::Isaev`

Different Black pieces arrive on the same square with line openings, line closures, self-blocks, or self-pins producing distinct mates.

```thema
def [a:!K b:!K]
key K [A B]
where same_square(a, b), a.role != b.role,
  a.from != b.from, K.threat_count > 0,
  (!a.capture || (a.self_pins_for(A)
    && b.self_pins_for(B))),
  (a.unpins(A) || b.unpins(B) || a.self_pins_for(A)
    || b.self_pins_for(B) || (a.cuts_enemy_line()
    && (a.opens_line(WK) || b.opens_line(WK)
    || a.interferes_for(A) || b.interferes_for(B)
    || a.unguards(A) || b.unguards(B))))
story "Isaev: Key 1.{K}!{threat_clause} meets different
  Black pieces defending on {a.to} with checkmates
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Finnish Novotny
**Enum**: `NamedTheme::FinnishNovotny`

A Novotny interference where the sacrificing piece is captured by both Rook and Bishop.

```thema
def [a:R:x@K b:B:x@K]
key K [A B]
where a.mutually_blocks(b, A, B)
with -match_mate_count
subsumes DoubleSacrificeKey
story "Finnish Novotny: Key 1.{K}!{threat_clause}
  sacrifices on the intersection; capture defenses 1...{a}
  and 1...{b} allow 2.{A}# and 2.{B}#."
```

### Perfect Novotny
**Enum**: `NamedTheme::PerfectNovotny`

Novotny interference with at least 3 capturing defenses on the intersection square, or a single threat with two distinct checkmates.

```thema
def [a:R:x@K b:B:x@K c:x@K]
key K [A* B* C*]
where distinct(a.from, b.from, c.from),
  a.mutually_blocks(b, A, B)
with -match_mate_count
story "Perfect Novotny: Key 1.{K}!{threat_clause}
  sacrifices on the intersection, met by three
  capturing defenses: 1...{a} 2.{A}#, 1...{b} 2.{B}#,
  1...{c} 2.{C}#."
---
def [a:R:x@K b:B:x@K]
key K (T) [A* B*]
where distinct(T, A, B), a.mutually_blocks(b, A, B)
with -match_mate_count
subsumes FinnishNovotny
story "Perfect Novotny: Key 1.{K}! (threat 2.{T}#)
  sacrifices on {K.to}; captures 1...{a} and 1...{b} allow
  distinct mates 2.{A}# and 2.{B}#."
```

### Anticipatory interference
**Enum**: `NamedTheme::AnticipatoryInterference`

A line is closed in advance behind an obstacle before the defending piece moves along it.

```thema
key K [A]
where !K.capture, A.from != K.to, a.slider, a.capture,
  between(a.to, a.from, K.to)
story "Anticipatory interference:
  Key 1.{K}!{threat_clause} closes a line in advance,
  enabling 2.{A}# against 1...{a}."
```

### Romanian Novotny
**Enum**: `NamedTheme::RomanianNovotny`

Novotny sacrifice on intersection captured by Black King and other pieces.

```thema
def [a:x@K b:x@K c:K:x@K]
key K [A B C]
where a.ortho_slider, b.diag_slider, a.ortho, b.diag,
  distinct(a.from, b.from, c.from),
  a.mutually_blocks(b, A, B)
story "Romanian Novotny: Key 1.{K}!{threat_clause}
  sacrifices on the intersection, captured by the Black
  King and pieces: 1...{a} 2.{A}#, 1...{b} 2.{B}#,
  1...{c} 2.{C}#."
---
def [a:R:x@K b:B:x@K]
any K (T) [A B]
where a.mutually_blocks(b, A, B)
story "Romanian Novotny: 1.{K}! (threat 2.{T}#) sacrifices
  on the intersection; captures 1...{a} and 1...{b} allow
  2.{A}# and 2.{B}#."
---
def [a:R b:B]
any K (XY) [A B]
where same_square(a, b), a.from != b.from, a.capture,
  b.capture,
  (a.mutually_blocks(b, A, B) || (a.closes_line()
    && b.closes_line()))
with -match_threat_count -single_refutation
  -capture_try_piece
subsumes Novotny
story "Romanian Novotny: 1.{K}! (threats 2.{X}#,
  2.{Y}#) sacrifices on the intersection; captures
  1...{a} and 1...{b} defeat both threats and allow 2.{A}#
  and 2.{B}#."
```

### Holzhausen
**Enum**: `NamedTheme::Holzhausen`

Mutual interference between two pieces of the same motion type on the same line.

```thema
key [A B]
where a.role == b.role, (a.role in {'R', 'B'}),
  collinear(a.from, b.from, a.to),
  between(a.to, a.from, b.from),
  (a.interferes_for(A) || b.interferes_for(B)
    || a.mutually_blocks(b, A, B))
story "Holzhausen: Key 1.{K}!{threat_clause} induces
  mutual interference between two pieces of the same
  motion type: 1...{a} 2.{A}# vs 1...{b} 2.{B}#."
---
key [A B]
where same_piece(a, b), a.role == 'Q',
  (a.interferes_with('R') || a.interferes_with('B')),
  (b.interferes_with('R') || b.interferes_with('B'))
story "Holzhausen: Key 1.{K}!{threat_clause} induces
  the Black Queen to interfere with Rook/Bishop lines:
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Barulin (A)
**Enum**: `NamedTheme::BarulinA`

Barulin theme type A: multiple Black pieces defend on the same square(s) with mutual interference, multi-piece convergence, or multi-phase separation.

```thema
vir [A B]
key K [C D]
where same_square(a, b), a.from != b.from,
  {a.role, b.role} == {'R', 'B'}, K.threat_count > 0
with -match_threat_count
story "Barulin A: Mutual interference between 1...{a} and
  1...{b} on {a.to} recurs across phases, answered after
  Key 1.{K}!{threat_clause} by 2.{C}# and 2.{D}#."
---
key K [A B]
where {a.role, b.role} == {'R', 'B'}, !a.capture,
  K.threat_count > 0, mutual_obstruction(a, b, A, B)
story "Barulin A: Key 1.{K}!{threat_clause} causes mutual
  interference on {a.to}: 1...{a} allows 2.{A}# vs 1...{b}
  allows 2.{B}#."
---
key K [A B C D]
where K.threat_count > 0, same_square(a, b),
  a.from != b.from, {a.role, b.role} == {'R', 'B'},
  same_square(c, d), c.from != d.from,
  {c.role, d.role} == {'R', 'B'}, a.to != c.to
story "Barulin A: Doubled same-square defenses after
  Key 1.{K}!{threat_clause}: 1...{a}/1...{b} on {a.to}
  (2.{A}#, 2.{B}#) and 1...{c}/1...{d} on {c.to}
  (2.{C}#, 2.{D}#)."
---
key K [A B C]
where K.threat_count > 0, same_square(a, b, c),
  distinct(a.from, b.from, c.from), (a, b, c).role != 'K',
  {a.role, b.role} == {'R', 'B'}
story "Barulin A: Three Black pieces converge on {a.to}
  after Key 1.{K}!{threat_clause}: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Latvian Novotny
**Enum**: `NamedTheme::LatvianNovotny`

Mutual capture on Novotny intersection square adjacent to the Black King or in virtual play.

```thema
def [a:R:x@K b:B:x@K]
key K [A B]
where K.flight_block, a.mutually_blocks(b, A, B)
story "Latvian Novotny: Key 1.{K}!{threat_clause}
  sacrifices on the intersection adjacent to the Black
  King: 1...{a} 2.{A}# vs 1...{b} 2.{B}#."
---
vir [A B]
key K
where same_square(a, b), a.from != b.from,
  {a.role, b.role} == {'R', 'B'}, a.closes_line(),
  b.closes_line()
with -match_threat_count -match_mate_count
  -single_refutation -capture_try_piece
story "Latvian Novotny: Rook and Bishop interference
  on {a.to} in virtual play (1...{a} 2.{A}#
  vs 1...{b} 2.{B}#) before Key 1.{K}!{threat_clause}."
---
vir [A* _]
+any K [B C]
where same_square(a, b), a.from != b.from, a.capture,
  b.capture, a.to != K.to, {a.role, b.role} == {'R', 'B'}
with -match_threat_count -match_mate_count
  -single_refutation -capture_try_piece
story "Latvian Novotny: Captures 1...{a} and
  1...{b} on {a.to} allow 2.{B}# and 2.{C}# after
  1.{K}!{threat_clause}."
```

### Masked interference
**Enum**: `NamedTheme::MaskedInterference`

An interference occurring behind an existing obstruction on a line of action.

```thema
key K [A]
where (a.closes_line(A.to) || (a.closes_line(A.from)
    && between(A.from, a.to, A.to))),
  a.role != 'K',
  (between(A.from, a.to, A.to)
    || collinear(K.from, a.to, A.to) || (!a.capture
    && !A.capture && A.from == K.to))
subsumes LineClosure
story "Masked interference: Key 1.{K}!{threat_clause}
  provokes defense 1...{a} which interferes with a masked
  line behind an obstacle, allowing 2.{A}#."
```

### Clearance sacrifice
**Enum**: `NamedTheme::ClearanceSacrifice`

A piece is sacrificed specifically to vacate a square or open a line for another piece.

```thema
def [a@K]
key K [A@K]
where collinear(A.from, K.from, K.to), A.from != K.from
subsumes ActiveSacrifice, Kozhakin
story "Clearance sacrifice: Key 1.{K}!{threat_clause}
  sacrifices the key piece to clear the square for
  mate 2.{A}#."
```

### Brede clearance
**Enum**: `NamedTheme::BredeClearance`

A line clearance where the cleared piece delivers mate from another direction.

```thema
key K:Q [A:N@K.from]
with -match_mate_count
subsumes Clearance
story "Brede clearance: Key 1.{K}!{threat_clause}
  vacates {K.from}, enabling Knight checkmate 2.{A}#
  against 1...{a}."
---
key K:Q (Thr:N@K.from)
with -match_threat_count
subsumes Clearance
story "Brede clearance: Key 1.{K}! vacates {K.from}
  to prepare Knight checkmate threat 2.{Thr}#."
```

### Grimshaw in Try
**Enum**: `NamedTheme::GrimshawTry`

A Grimshaw mutual interference occurs within the variations or refutations of a try phase.

```thema
def [a b]
try (_) [A B]
where {a.role, b.role} == {'R', 'B'},
  a.mutually_blocks(b, A, B)
with -single_refutation -capture_try_piece
  -refutation_is_check -no_threats_sparse_mates
  -no_threats_few_replies -match_mate_count
  -match_threat_count
story "Grimshaw in Try: Grimshaw mutual interference
  occurs in Try 1.{Tr}? play: 1...{a} 2.{A}#
  vs 1...{b} 2.{B}#."
---
try (_) [! _]
try (_) [_ !]
key [A B]
where same_square(a, b), {a.role, b.role} == {'R', 'B'},
  a.from != b.from
with -single_refutation -capture_try_piece
  -refutation_is_check -no_threats_sparse_mates
  -no_threats_few_replies -match_mate_count
  -match_threat_count
story "Grimshaw in Try: Grimshaw mutual interference
  on {a.to} across try refutations 1...{a}! (to
  1.{Tr1}?) and 1...{b}! (to 1.{Tr2}?), resolved
  by Key 1.{K}!{threat_clause}."
```

### Grimshaw in set play
**Enum**: `NamedTheme::GrimshawSetPlay`

A Grimshaw mutual interference is present in the set play of the problem.

```thema
set [A B]
where same_square(a, b), {a.role, b.role} == {'R', 'B'},
  a.from != b.from, mutual_obstruction(a, b, A, B)
with -match_mate_count
story "Grimshaw in set play: Grimshaw mutual
  interference on {a.to} in set play: 1...{a} 2.{A}#
  vs 1...{b} 2.{B}#."
```

### Novotny in Try
**Enum**: `NamedTheme::NovotnyTry`

A Novotny interference key sacrifice is executed as a try, refuted by Black.

```thema
try Tr
where Tr.cuts_enemy_line('R'), Tr.cuts_enemy_line('B')
with -capture_try_piece
story "Novotny in Try: Novotny sacrificial interference
  occurs as a try 1.{Tr}?."
```

### Boros
**Enum**: `NamedTheme::Boros` · *Alias*: Boros pin-mate

Mutual interference between two Black defenses on the same square answered by pin-mates, or Black defense self-blocking while indirectly unpinning.

```thema
key [A B]
where same_square(a, b), a.from != b.from, (A, B).pin_mate
story "Boros: Key 1.{K}!{threat_clause} induces mutual
  interference on {a.to}, answered by dual pin-mates:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
def [a:!K]
any [A]
where a.unpins(BK), a.self_block
subsumes PinMate
story "Boros: Defense 1...{a} indirectly unpins a Black
  piece while self-blocking, conceding checkmate 2.{A}#."
```

### Bi-coloured Bristol
**Enum**: `NamedTheme::BicoloredBristol` · *Alias*: Bicolor Bristol

Line clearance between pieces of opposite colors: a White slider key clears a line for a Black slider defense to traverse its origin square, or a Black slider defense clears a line for a White slider mate.

```thema
def [a:Q|R|B]
key K:Q|R|B [A]
where K.clears_line_for(a)
story "Bi-coloured Bristol: White {K.role_name} key
  1.{K}! clears the line across {K.from} for Black's
  {a.role_name} defense 1...{a}, met by 2.{A}#."
---
def [a:Q|R|B]
key [A:Q|R|B]
where a.clears_line_for(A)
story "Bi-coloured Bristol: Black {a.role_name}
  move 1...{a} clears the line across {a.from} for
  White's {A.role_name} to traverse it and deliver
  checkmate 2.{A}#."
```

### Azerbaijani Novotny
**Enum**: `NamedTheme::AzerbaijaniNovotny`

White key sacrifices on the intersection square of a Black Rook and Bishop with a double threat (XY); captures by the Rook and Bishop mutually interfere to allow two other checkmates A and B.

```thema
def [a:R:x@K b:B:x@K]
key K (XY) [A B]
where a.from != b.from, a.mutually_blocks(b, A, B)
subsumes DoubleThreat, Novotny
story "Azerbaijani Novotny: Key 1.{K}! (threats 2.{XY}#)
  sacrifices on {K.to}; captures by Rook (1...{a}
  2.{A}#) and Bishop (1...{b} 2.{B}#) yield two further
  checkmates."
```

### English Grimshaw
**Enum**: `NamedTheme::EnglishGrimshaw`

Mutual interference between a Black Queen and a Black Rook or Bishop arriving on the same non-capturing intersection square.

```thema
def [a:Q:!x b:R|B:!x]
key [A B]
where a.ortho != b.ortho, a.mutually_blocks(b, A, B)
subsumes DefencesOnSameSquare, Laitinen
story "English Grimshaw: Key 1.{K}!{threat_clause} induces
  mutual interference on {a.to} between Black Queen
  (1...{a} 2.{A}#) and {b.role_name} (1...{b} 2.{B}#)."
```

### English Novotny
**Enum**: `NamedTheme::EnglishNovotny`

White key sacrifices on an intersection square where captures by the Black Queen and a Black Rook or Bishop mutually interfere with each other.

```thema
def [a:Q:x@K b:R|B:x@K]
key K [A B]
where a.from != b.from, a.ortho != b.ortho
story "English Novotny: Key 1.{K}!{threat_clause}
  sacrifices on {K.to}, provoking mutual interference
  between capturing Queen (1...{a} 2.{A}#) and
  {b.role_name} (1...{b} 2.{B}#)."
---
key K (AB)
where K.cuts_enemy_line('Q'),
  K.cuts_enemy_line('R') || K.cuts_enemy_line('B')
subsumes ActiveSacrifice, DoubleThreat
story "English Novotny: Key 1.{K}! cuts the lines
  of the Black Queen and Rook/Bishop on {K.to},
  creating double threat 2.{AB}#."
```

### Double bind Grimshaw
**Enum**: `NamedTheme::DoubleBindGrimshaw`

Four distinct Black line pieces (Rooks, Bishops, or Queen) move to the same non-capturing intersection square, each allowing a distinct checkmate.

```thema
def [a:!x b:!x c:!x d:!x]
key [A B C D]
where same_square(a, b, c, d),
  distinct(a.from, b.from, c.from, d.from),
  (a, b, c, d).slider
subsumes CederInterference, EnglishGrimshaw, Grimshaw,
  Pickabish, Stocchi
story "Double bind Grimshaw: Key 1.{K}!{threat_clause}
  compels four Black sliders to converge on {a.to}
  with four distinct checkmates: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#, 1...{d} 2.{D}#."
```

### Brojt
**Enum**: `NamedTheme::Brojt` · *Alias*: Double-Decker Novotny

Synthesis of Novotny sacrifice on the key's arrival square and Grimshaw mutual interference between a Black Rook and Bishop on a second square.

```thema
def [a:R:x@K b:B:x@K c:R:!x d:B:!x]
key K [A B C D]
where c.mutually_blocks(d, C, D), c.to != K.to
subsumes DoubleSacrificeKey, Grimshaw, Novotny,
  RookSacrifice
story "Brojt (Double-Decker Novotny):
  Key 1.{K}!{threat_clause} combines a Novotny sacrifice
  on {K.to} (1...{a} 2.{A}#, 1...{b} 2.{B}#) with
  a Grimshaw interference on {c.to} (1...{c} 2.{C}#,
  1...{d} 2.{D}#)."
```

### Loyd-Turton
**Enum**: `NamedTheme::LoydTurton` · *Alias*: Loyd Turton

Stronger White line-piece (Queen) crosses the intersection square along a line so a weaker White line-piece (Rook or Bishop) moves onto that line in front of it to deliver checkmate.

```thema
key K:Q [A:R|B]
where K.from != A.from, collinear(K.from, K.to, A.to),
  between(A.to, K.to, BK), K.dir != A.dir
story "Loyd-Turton: White Queen key 1.{K}!{threat_clause}
  withdraws along the line so the {A.role_name} can step
  in front and deliver checkmate 2.{A}# after 1...{a}."
```

### Brunner-Turton
**Enum**: `NamedTheme::BrunnerTurton` · *Alias*: Brunner Turton

Two White line-pieces of equal value (two Rooks or two Bishops) execute a Turton doubling along a line.

```thema
key K:R|B [A:R|B]
where K.role == A.role, K.from != A.from,
  collinear(K.from, K.to, A.to), between(A.to, K.to, BK),
  K.dir != A.dir
story "Brunner-Turton: White {K.role_name} key
  1.{K}!{threat_clause} crosses the intersection square
  to double with the second {A.role_name}, which delivers
  2.{A}# after 1...{a}."
```

### Zepler doubling
**Enum**: `NamedTheme::ZeplerDoubling` · *Alias*: Zepler

Forward White line-piece moves along the line toward the target first, allowing a trailing White line-piece already behind it on that line to advance along the same line to deliver mate.

```thema
key K:Q|R|B [A:Q|R|B]
where K.from != A.from, collinear(A.from, K.from, K.to),
  between(K.from, A.from, K.to), K.dir == A.dir
subsumes BristolClearance
story "Zepler doubling: Forward {K.role_name}
  1.{K}!{threat_clause} advances along the line, allowing
  the trailing {A.role_name} on {A.from} to follow along
  the same line with 2.{A}# after 1...{a}."
```

### Kockelkorn clearance
**Enum**: `NamedTheme::Kockelkorn` · *Alias*: Kockelkorn

White key piece vacates its square off-line so that another White piece lands directly on that exact vacated square to deliver checkmate.

```thema
key K [A@K.from]
where K.from != A.from, !collinear(K.from, K.to, A.from)
story "Kockelkorn clearance: Key 1.{K}!{threat_clause}
  vacates {K.from}, allowing White's {A.role_name}
  to occupy {K.from} and deliver 2.{A}# after 1...{a}."
```

### Loyd line clearance
**Enum**: `NamedTheme::LoydClearance` · *Alias*: Loyd clearance

White line-piece moves along a line past a square so that a second White piece can move along that same line onto that vacated intermediate square to deliver checkmate.

```thema
key K:Q|R|B [A]
where K.from != A.from, collinear(K.from, K.to, A.to),
  between(A.to, K.from, K.to),
  collinear(A.from, K.from, K.to),
  between(K.from, A.from, K.to)
subsumes CriticalMove
story "Loyd line clearance: White {K.role_name} key
  1.{K}!{threat_clause} sweeps past {A.to}, clearing
  the line and square for 2.{A}# after 1...{a}."
```

### Double Bristol
**Enum**: `NamedTheme::DoubleBristol`

Two distinct Bristol line-clearances occur across two defensive variations.

```thema
key K:Q|R|B [A:Q|R|B B:Q|R|B]
where K.clears_line_for(A), K.clears_line_for(B)
story "Double Bristol: Key 1.{K}!{threat_clause}
  clears the line for two distinct Bristol mates:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
def [a:Q|R|B b:Q|R|B]
key [A:Q|R|B B:Q|R|B]
where a.clears_line_for(A), b.clears_line_for(B)
story "Double Bristol: Two Black slider defenses clear
  lines for White slider mates: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Black Bristol
**Enum**: `NamedTheme::BlackBristol`

Two collinear Black line-pieces move in the same direction along their shared line of action across variations.

```thema
def [a:Q|R|B b:Q|R|B]
key [A B]
where diff_piece(a, b), a.to != b.to,
  collinear(a.from, b.from, a.to), a.dir == b.dir,
  between(a.from, b.from, b.to)
story "Black Bristol: After Key 1.{K}!{threat_clause},
  Black {a.role_name} move 1...{a} (2.{A}#) and
  {b.role_name} move 1...{b} (2.{B}#) exhibit Black
  Bristol line play."
```

### Würzburg clearance
**Enum**: `NamedTheme::WurzburgClearance` · *Alias*: Wurzburg clearance

The key piece vacates a critical square that is subsequently traversed orthogonally in one variation mate and diagonally in another variation mate.

```thema
key K [A:Q|R B:Q|B]
where A.ortho, B.diag, between(K.from, A.from, A.to),
  between(K.from, B.from, B.to)
subsumes GateOpening, LineOpening
story "Würzburg clearance: Key 1.{K}!{threat_clause}
  vacates {K.from}, which is traversed orthogonally
  in 1...{a} 2.{A}# and diagonally in 1...{b} 2.{B}#."
```

### Hungarian Novotny
**Enum**: `NamedTheme::HungarianNovotny`

White sacrifices on the intersection square of a Black Rook and Bishop, where at least one of the capturing defenses also self-blocks the Black King.

```thema
def [a:R:x@K b:B:x@K]
key K [A B]
where a.mutually_blocks(b, A, B),
  (a.self_block || b.self_block)
subsumes Decoy, FinnishNovotny, SelfBlock
story "Hungarian Novotny: Key 1.{K}!{threat_clause}
  sacrifices on {K.to}, combining Novotny mutual
  interference with a self-block: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Czech Novotny
**Enum**: `NamedTheme::CzechNovotny`

Novotny sacrifice on the intersection square of a Black Rook and Bishop where both resulting checkmates are pure mates.

```thema
def [a:R:x@K b:B:x@K]
key K [A B]
where a.mutually_blocks(b, A, B), (A, B).pure_mate
subsumes DoublePureMate, FinnishNovotny
story "Czech Novotny: Key 1.{K}!{threat_clause} sacrifices
  on {K.to}, producing pure checkmates after Rook and
  Bishop captures: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
def [a:R:x b:B:x]
key K [A B]
where a.to == b.to, a.mutually_blocks(b, A, B),
  (A, B).pure_mate
subsumes DoublePureMate, LatvianNovotny
story "Czech Novotny: Key 1.{K}!{threat_clause} sets up
  a Novotny sacrifice on {a.to}, producing pure checkmates
  after 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Polish Novotny
**Enum**: `NamedTheme::PolishNovotny`

Novotny sacrifice on the intersection of a Black Rook and Bishop where the same White piece delivers two distinct checkmates after the captures.

```thema
def [a:R:x@K b:B:x@K]
key K [A B]
where a.mutually_blocks(b, A, B), same_piece(A, B),
  A.to != B.to
subsumes FinnishNovotny
story "Polish Novotny: Key 1.{K}!{threat_clause}
  sacrifices on {K.to}, and the same White {A.role_name}
  delivers both mates: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Dutch Novotny
**Enum**: `NamedTheme::DutchNovotny`

Novotny sacrifice on the intersection of a Black Rook and Bishop where at least one capture simultaneously opens a White line of attack.

```thema
def [a:R:x@K b:B:x@K]
key K [A B]
where a.mutually_blocks(b, A, B),
  (a.opens_line(A) || b.opens_line(B))
subsumes FinnishNovotny
story "Dutch Novotny: Key 1.{K}!{threat_clause} sacrifices
  on {K.to}, combining Novotny interference with line
  opening: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Russian Novotny
**Enum**: `NamedTheme::RussianNovotny`

Two Novotny tries on distinct intersection squares.

```thema
def [a:R:x@Tr1 b:B:x@Tr1 c:R:x@Tr2 d:B:x@Tr2]
try Tr1 [A B _ _]
try Tr2 [_ _ C D]
where Tr1.to != Tr2.to, a.mutually_blocks(b, A, B),
  c.mutually_blocks(d, C, D)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay, TransferredMates
story "Russian Novotny: Twin Novotny tries 1.{Tr1}?
  on {Tr1.to} (1...{a} 2.{A}#, 1...{b} 2.{B}#) and
  1.{Tr2}? on {Tr2.to} (1...{c} 2.{C}#, 1...{d} 2.{D}#)."
```

### Double Novotny
**Enum**: `NamedTheme::DoubleNovotny`

Two distinct Novotny sacrifices occur across a try phase and the key phase on different intersection squares.

```thema
def [a:R:x@Tr b:B:x@Tr c:R:x@K d:B:x@K]
try Tr [A B _ _]
key K [_ _ C D]
where Tr.to != K.to, a.mutually_blocks(b, A, B),
  c.mutually_blocks(d, C, D)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedMate, FinnishNovotny, LatvianNovotny,
  TransferredMates
story "Double Novotny: Novotny in Try 1.{Tr}? on {Tr.to}
  (1...{a} 2.{A}#, 1...{b} 2.{B}#) followed by Novotny in
  Key 1.{K}! on {K.to} (1...{c} 2.{C}#, 1...{d} 2.{D}#)."
```

### Double Grimshaw
**Enum**: `NamedTheme::DoubleGrimshaw`

Two Grimshaw mutual interferences between Black Rooks and Bishops on two distinct intersection squares in the same phase.

```thema
def [a:R:!x b:B:!x c:R:!x d:B:!x]
key [A B C D]
where a.to != c.to, a.mutually_blocks(b, A, B),
  c.mutually_blocks(d, C, D)
subsumes DefencesOnSameSquare, Grimshaw, Laitinen,
  LineClosure
story "Double Grimshaw: Key 1.{K}!{threat_clause} forces
  two Grimshaw mutual interferences on {a.to} (1...{a}
  2.{A}#, 1...{b} 2.{B}#) and {c.to} (1...{c} 2.{C}#,
  1...{d} 2.{D}#)."
```

### Pawn Grimshaw
**Enum**: `NamedTheme::PawnGrimshaw`

Mutual interference between a Black Pawn and a Black Rook or Bishop arriving on the same non-capturing square.

```thema
def [a:P:!x b:R|B:!x]
key [A B]
where a.to == b.to, a.from != b.from,
  b.blocks_line(a, B) || a.blocks_line(b, A)
subsumes DefencesOnSameSquare, Laitinen
story "Pawn Grimshaw: Key 1.{K}!{threat_clause} induces
  interference on {a.to} between Black Pawn (1...{a}
  2.{A}#) and {b.role_name} (1...{b} 2.{B}#)."
```

### Pawn Novotny
**Enum**: `NamedTheme::PawnNovotny`

White key piece sacrifices on a square where captures by a Black Pawn and a Black Rook or Bishop interfere with each other.

```thema
def [a:P:x@K b:R|B:x@K]
key K [A B]
where a.from != b.from, a.blocks_line(b, A)
subsumes DoubleSacrificeKey
story "Pawn Novotny: Key 1.{K}!{threat_clause} sacrifices
  on {K.to}, where captures by Black Pawn (1...{a} 2.{A}#)
  and {b.role_name} (1...{b} 2.{B}#) interfere."
```

### Plachutta in Try
**Enum**: `NamedTheme::PlachuttaTry`

Plachutta interference between two orthogonally or diagonally like-moving Black sliders in a try phase.

```thema
def [a:R|B:x@Tr b:R|B:x@Tr]
try Tr [A B]
where a.role == b.role, a.from != b.from,
  a.mutually_blocks(b, A, B)
story "Plachutta in Try: Try 1.{Tr}? sacrifices on
  {Tr.to}, inducing mutual interference between two Black
  {a.role_name}s: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Interference cross-check
**Enum**: `NamedTheme::InterferenceCrossCheck`

Two Black checking defenses arrive on the same square (interfering with each other) and are met by distinct non-capturing cross-check mates.

```thema
def [a:+ b:+]
key [A!@a B!@b]
where a.to == b.to, a.from != b.from
subsumes DefencesOnSameSquare, DoubleCrossCheck, Laitinen
story "Interference cross-check:
  After Key 1.{K}!{threat_clause}, Black checks 1...{a}
  and 1...{b} on {a.to} are met by distinct cross-checks
  2.{A}# and 2.{B}#."
```

### Anti-Roman
**Enum**: `NamedTheme::AntiRoman` · *Alias*: Anti-Roman defence

A Black piece defends on one square to allow mate A in a try while its move to a second square refutes the try; after the key, both moves by that Black piece allow distinct mates A and B.

```thema
def [a:!K b:!K]
try (X) [A !]
key (X) [A B]
where same_piece(a, b), a.to != b.to,
  (a.interferes_for(A) || b.interferes_for(B)
    || a.self_block || b.self_block || a.self_pins_for(A)
    || b.self_pins_for(B))
story "Anti-Roman: Black's {a.role_name} on {a.from}
  refutes Try 1.{Tr}? with 1...{b}! (while 1...{a}
  allowed 2.{A}#); after Key 1.{K}!{threat_clause},
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Feldmann 1
**Enum**: `NamedTheme::Feldmann1`

A square-vacating key threatens mate while Black slider defenses open and close lines, separating mates by the key piece and other White pieces.

```thema
key K [A B]
where a.slider, b.slider, a.from != b.from,
  A.from == K.to, B.from != K.to,
  (a.opens_line() || a.closes_line() || b.opens_line()
    || b.closes_line())
story "Feldmann 1: Key 1.{K}!{threat_clause} vacates
  {K.from}; slider defenses 1...{a} and 1...{b} separate
  2.{A}# (by the key piece) and 2.{B}#."
```

### Feldmann 2
**Enum**: `NamedTheme::Feldmann2` · *Alias*: Tagilskaya

A try and the key by the same White slider produce changed mates against Black Knight correction defenses.

```thema
def [a:N b:N]
try Tr [A B]
key K [C D]
where same_piece(Tr, K), Tr.slider, same_piece(a, b),
  a.to != b.to
subsumes ChangedPlay
story "Feldmann 2 (Tagilskaya): Slider try 1.{Tr}? and
  Key 1.{K}! produce changed mates against Knight defenses
  1...{a} and 1...{b}: 2.{A}#/2.{B}# to 2.{C}#/2.{D}#."
```

### Chicco
**Enum**: `NamedTheme::Chicco` · *Alias*: Chicco theme

A sacrificial key sets up a Grimshaw on an adjacent square while capturing the key piece with one of the Grimshaw sliders produces a third distinct mate.

```thema
def [a:!x b:!x c:R|B:x@K]
key K [A B C]
where {a.role, b.role} == {'R', 'B'},
  a.mutually_blocks(b, A, B),
  same_piece(a, c) || same_piece(b, c)
subsumes ActiveSacrifice, DefencesOnSameSquare, Grimshaw,
  Laitinen
story "Chicco: Sacrificial Key 1.{K}!{threat_clause} sets
  up Grimshaw on {a.to} (1...{a} 2.{A}#, 1...{b} 2.{B}#)
  plus capture variation 1...{c} 2.{C}#."
```

### Baku Novotny
**Enum**: `NamedTheme::BakuNovotny`

Captures by a Black Rook and Bishop on the same square produce one pair of mates in set/try play and a completely changed pair of mates after the key.

```thema
def [a:R:x b:B:x]
vir [A B]
key [C D]
where a.mutually_blocks(b, C, D)
subsumes Novotny, OneLineHerpai
story "Baku Novotny: Captures 1...{a} and 1...{b}
  on {a.to} change mates from 2.{A}#/2.{B}# in virtual
  play to 2.{C}#/2.{D}# after Key 1.{K}!."
```

### Norwegian Novotny
**Enum**: `NamedTheme::NorwegianNovotny`

A try sacrifices on a Rook-Bishop intersection (Latvian Novotny) with mates A and B; the key plays elsewhere and captures on that square produce changed mates C and D.

```thema
def [a:R:x b:B:x c]
try Tr [A B !]
key K [C D _]
where a.mutually_blocks(b, A, B), a.to == b.to,
  K.to != Tr.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes BakuNovotny, Novotny
story "Norwegian Novotny: Try 1.{Tr}? induces Rook/Bishop
  captures 1...{a} 2.{A}# and 1...{b} 2.{B}# (refuted
  by 1...{c}!), changed after Key 1.{K}! to 2.{C}#
  and 2.{D}#."
```

### Pickabish-Novotny
**Enum**: `NamedTheme::PickabishNovotny`

White key sacrifices on a square where a Black Pawn and a Black Bishop both capture it, mutually interfering with each other.

```thema
def [a:P:x@K b:B:x@K]
key K [A B]
where a.from != b.from, a.blocks_line(b, A)
subsumes DoubleSacrificeKey, PawnNovotny
story "Pickabish-Novotny: Key 1.{K}!{threat_clause}
  sacrifices on {K.to}; captures 1...{a} (Pawn) and
  1...{b} (Bishop) mutually interfere, allowing 2.{A}#
  and 2.{B}#."
```

### Greek Novotny
**Enum**: `NamedTheme::GreekNovotny` · *Alias*: Berger theme

Two tries each provoke one half of a Rook-Bishop Grimshaw allowing mate A while being refuted by the other piece; the key plays A as first move.

```thema
def [a:!x b:!x]
try Tr1 [A !]
try Tr2 [! A]
key A [C D]
where {a.role, b.role} == {'R', 'B'},
  a.mutually_blocks(b, C, D)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes AntiGrimshaw, Arnhem, Caprice,
  DefencesOnSameSquare, Grimshaw, Laitinen
story "Greek Novotny (Berger): Tries 1.{Tr1}? (1...{a}
  2.{A}#; 1...{b}!) and 1.{Tr2}? (1...{b} 2.{A}#;
  1...{a}!) lead to Key 1.{A}!, answering 1...{a} 2.{C}#
  and 1...{b} 2.{D}#."
---
def [a:!x b:!x]
try C [A !]
try D [! A]
key A [C D]
where {a.role, b.role} == {'R', 'B'}, a.to == b.to,
  a.from != b.from
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes AntiGrimshaw, Arnhem, Caprice,
  DefencesOnSameSquare, Grimshaw, Laitinen
story "Greek Novotny (Berger): Tries 1.{C}? (1...{a}
  2.{A}#; 1...{b}!) and 1.{D}? (1...{b} 2.{A}#;
  1...{a}!) lead to Key 1.{A}!, answering 1...{a} 2.{C}#
  and 1...{b} 2.{D}#."
```

### Remote Novotny
**Enum**: `NamedTheme::RemoteNovotny`

Virtual play has a Grimshaw of defenses a and b on K.to allowing mates A and B; Key K sacrifices on K.to, threatening AB and answering captures a and b with mates A and B.

```thema
def [a:R b:B]
vir [A B]
key K (AB) [A B]
where a.mutually_blocks(b, A, B), a.to == K.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Novotny, Rudenko
story "Remote Novotny: Set Grimshaw on {K.to} (1...{a}
  2.{A}#, 1...{b} 2.{B}#) becomes sacrificial Key 1.{K}!
  threatening 2.{A}# and 2.{B}#."
```

### Schiffmann Novotny
**Enum**: `NamedTheme::SchiffmannNovotny`

White key sacrifices on an intersection square where two Black sliders capture (at least one giving check) and self-pin, allowing battery/cross-check mates.

```thema
def [a:x@K:+ b:x@K]
key K [A B]
where a.slider, b.slider, a.from != b.from,
  (a.self_pins || b.self_pins || A.fires_battery
    || B.fires_battery)
subsumes DoubleSacrificeKey, ProvokedCheck
story "Schiffmann Novotny: Sacrificial
  Key 1.{K}!{threat_clause} on {K.to} provokes checking
  capture 1...{a} (2.{A}#) and 1...{b} (2.{B}#)."
```

### Boros Novotny
**Enum**: `NamedTheme::BorosNovotny`

White key sacrifices on a Black King flight square, so captures by Black Rook, Bishop, and King produce three distinct checkmates.

```thema
def [a:R:x@K b:B:x@K c:K:x@K]
key K [A B C]
where a.mutually_blocks(b, A, B)
subsumes DoubleSacrificeKey, RoyalSacrificeKey
story "Boros Novotny: Key 1.{K}!{threat_clause} sacrifices
  on flight square {K.to}; captures 1...{a}, 1...{b},
  and 1...{c} allow 2.{A}#, 2.{B}#, and 2.{C}#."
```

### Boros Grimshaw
**Enum**: `NamedTheme::BorosGrimshaw`

A non-capturing Grimshaw between Black Rook and Bishop takes place on a flight square adjacent to the Black King, where each move simultaneously creates a self-block.

```thema
def [a:!x b:!x]
key [A B]
where {a.role, b.role} == {'R', 'B'},
  a.mutually_blocks(b, A, B), (a, b).self_block
subsumes DefencesOnSameSquare, Grimshaw, Laitinen,
  LineClosure, SelfInterference
story "Boros Grimshaw: Key 1.{K}!{threat_clause}.
  Black Rook 1...{a} and Bishop 1...{b} mutually interfere
  and self-block on flight square {a.to}, allowing 2.{A}#
  and 2.{B}#."
```

### Latvian Plachutta
**Enum**: `NamedTheme::LatvianPlachutta`

A White try sacrifices on the intersection square of two like-moving Black sliders (Plachutta in try play), refuted by a third Black defense.

```thema
def [a:x@Tr b:x@Tr c]
try Tr [A B !]
where like_sliders(a, b), a.mutually_blocks(b, A, B)
story "Latvian Plachutta: Try 1.{Tr}? sacrifices
  on {Tr.to} for Plachutta captures 1...{a} 2.{A}# and
  1...{b} 2.{B}#, refuted by 1...{c}!."
```

### Boros Plachutta
**Enum**: `NamedTheme::BorosPlachutta`

Two like-moving Black sliders capture or move onto a square adjacent to the Black King, mutually interfering and self-blocking.

```thema
key [A B]
where like_sliders(a, b),
  !collinear(a.from, b.from, a.to),
  a.mutually_blocks(b, A, B), a.flight_block
subsumes DefencesOnSameSquare, Laitinen, Plachutta
story "Boros Plachutta: Key 1.{K}!{threat_clause}.
  Like-moving sliders 1...{a} and 1...{b} converge
  on flight square {a.to}, allowing 2.{A}# and 2.{B}#."
```

### Kubbel-Grimshaw
**Enum**: `NamedTheme::KubbelGrimshaw`

Two White tries are refuted by Black defenses a and b; after the key, those same two defenses interfere and allow the try moves or distinct mates.

```thema
try Tr1 [! _]
try Tr2 [_ !]
key K [A B]
where (a.closes_line() || b.closes_line()
    || same_square(a, b)),
  (A.to == Tr1.to || B.to == Tr2.to)
story "Kubbel-Grimshaw: Tries 1.{Tr1}? (1...{a}!)
  and 1.{Tr2}? (1...{b}!) are united by Key 1.{K}!,
  where 1...{a} and 1...{b} allow 2.{A}# and 2.{B}#."
```

### White Novotny
**Enum**: `NamedTheme::WhiteNovotny`

Two different White pieces try moving to the same intersection square with a double threat, each refuted by a different Black defense.

```thema
try Tr1 (XY) [! _]
try Tr2 (XY) [_ !]
where Tr1.from != Tr2.from, Tr1.to == Tr2.to
with -match_threat_count
story "White Novotny: Two White pieces try occupying
  {Tr1.to}—1.{Tr1}? (refuted by 1...{a}!) and 1.{Tr2}?
  (refuted by 1...{b}!)—with double threat 2.{X}#/2.{Y}#."
```

### Royal Grimshaw
**Enum**: `NamedTheme::RoyalGrimshaw`

The White King makes a flight-giving key that sets up a Royal battery, and a Black slider's moves interfere or unguard to allow Royal/battery mates.

```thema
key K:K [A B]
where K.flights_given >= 1, a.slider, b.slider,
  (A.fires_battery || B.fires_battery || a.closes_line()
    || b.closes_line())
subsumes FlightGivingKey
story "Royal Grimshaw: White King Key 1.{K}! grants
  a flight and sets up Royal battery play after
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Ceder interference
**Enum**: `NamedTheme::CederInterference` · *Alias*: Ceder

At least three distinct Black pieces move without capturing to the same intersection square, each interfering with Black lines (without unguarding the mating square from departure) to allow distinct mates.

```thema
def [a:!x b:!x c:!x]
key [A B C]
where same_square(a, b, c),
  distinct(a.from, b.from, c.from),
  a.mutually_blocks(b, A, B), c.closes_line(C.to),
  !c.unguards(C.to), !attacks(c.from, C.to)
subsumes DefencesOnSameSquare, Grimshaw
story "Ceder interference: Key 1.{K}!{threat_clause}.
  Three Black pieces converge on {a.to} without capturing
  (1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#)."
```

### Schneider interference
**Enum**: `NamedTheme::SchneiderInterference`

Two tries and the key by the same White pawn (captures and pushes) create distinct line openings and interferences.

```thema
try Tr1:P [! _]
try Tr2:P [_ !]
key K:P [A B]
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to)
subsumes WhiteCorrection
story "Schneider interference: White pawn tries 1.{Tr1}?
  (1...{a}!) and 1.{Tr2}? (1...{b}!) lead to pawn
  Key 1.{K}!, answering with 2.{A}# and 2.{B}#."
```

### Harmonium Pipes
**Enum**: `NamedTheme::HarmoniumPipes`

Three Black sliders (two Bishops and one Rook, or two Rooks and one Bishop) mutually interfere across two intersection squares (a 3-slider subset of Organ Pipes).

```thema
def [a:R|B:!x b:R|B:!x c:R|B:!x d:R|B:!x]
key [A B C D]
where same_piece(a, b), a.to != b.to, same_square(a, c),
  same_square(b, d), distinct(a.from, c.from, d.from)
subsumes DefencesOnSameSquare, Laitinen, LineClosure,
  SelfInterference
story "Harmonium Pipes: Key 1.{K}!{threat_clause}.
  Three Black sliders mutually interfere on {a.to} and
  {b.to}: 1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#,
  1...{d} 2.{D}#."
```

### Avanta
**Enum**: `NamedTheme::Avanta` · *Alias*: Avanta theme

Combination of set/try Grimshaw or Organ-pipes interferences with a key that introduces Novotny or double-threat interference play.

```thema
vir [A B _ _]
key (XY) [_ _ C D]
where a.slider, b.slider, c.slider, d.slider
with -match_threat_count
subsumes KarlstromFleck
story "Avanta: Virtual slider interferences (1...{a}
  2.{A}#, 1...{b} 2.{B}#) are followed by double-threat
  Key 1.{K}! (2.{X}#/2.{Y}#) with 1...{c} 2.{C}# and
  1...{d} 2.{D}#."
```

### Theme Elmgren
**Enum**: `NamedTheme::Elmgren` · *Alias*: Elmgren

Try Tr by a White piece fails to Black slider defense a; Key K moves that same White piece to another square, clearing a line so defenses a and b form a Grimshaw on a.to allowing mates A and B.

```thema
def [a:!x b:!x]
try Tr [! _]
key K [A B]
where same_piece(Tr, K), Tr.to != K.to, K.opens_line(WK),
  {a.role, b.role} == {'R', 'B'},
  a.mutually_blocks(b, A, B)
with -single_refutation -match_threat_count
subsumes DefencesOnSameSquare, Grimshaw, Laitinen
story "Theme Elmgren: Try 1.{Tr}? fails to 1...{a}!;
  Key 1.{K}! clears a line so 1...{a} (2.{A}#) and 1...{b}
  (2.{B}#) form a Grimshaw on {a.to}."
---
def [a:!x b:!x]
try Tr (XY) [! _]
key K (XY) [A B]
where same_piece(Tr, K), Tr.to != K.to, K.opens_line(WK),
  {a.role, b.role} == {'R', 'B'},
  a.mutually_blocks(b, A, B)
with -single_refutation -match_threat_count
subsumes DefencesOnSameSquare, Grimshaw, Laitinen
story "Theme Elmgren: Try 1.{Tr}? fails to 1...{a}!;
  Key 1.{K}! clears a line so 1...{a} (2.{A}#) and 1...{b}
  (2.{B}#) form a Grimshaw on {a.to}."
```

### Nanning theme
**Enum**: `NamedTheme::NanningTheme`

Key K vacates square K.from, and Black Rook and Bishop defenses a and b both move to K.from (Grimshaw on the vacated key square), allowing mates A and B.

```thema
def [a:!x b:!x]
key K [A B]
where {a.role, b.role} == {'R', 'B'}, a.to == K.from,
  a.mutually_blocks(b, A, B)
subsumes AntiNovotny, Grimshaw
story "Nanning theme: Key 1.{K}!{threat_clause} vacates
  {K.from}, inducing a Rook-Bishop Grimshaw on {K.from}:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Bicolor bi-valve
**Enum**: `NamedTheme::BicolorBivalve` · *Alias*: Bicolor bi-valve theme

Two Black defenses on the same square simultaneously open White attack lines and close Black guard lines (combining Valve and Bivalve).

```thema
key [A B]
where same_square(a, b), a.from != b.from,
  (a.valve(A) || a.bivalve(A)),
  (b.valve(B) || b.bivalve(B))
subsumes DefencesOnSameSquare, Laitinen, Valve
story "Bicolor bi-valve: Key 1.{K}!{threat_clause}.
  Defenses 1...{a} and 1...{b} on {a.to} open and close
  both White and Black lines for 2.{A}# and 2.{B}#."
```

### Seilberger theme
**Enum**: `NamedTheme::Seilberger` · *Alias*: Seilberger

Moves of a Black Rook or slider along a line indirectly pin a Black piece while opening and closing Black lines (Bivalve + Black correction).

```thema
def [a:R|B|Q b:R|B|Q]
key [A B]
where same_piece(a, b), a.to != b.to,
  (a.bivalve(A) || b.bivalve(B)),
  (a.indirect_pins(BK) || b.indirect_pins(BK)
    || A.pin_mate || B.pin_mate)
subsumes Bivalve
story "Seilberger theme: Key 1.{K}!{threat_clause}.
  Slider moves 1...{a} (2.{A}#) and 1...{b} (2.{B}#)
  combine Bivalve line play with indirect pinning."
```

### Hume theme
**Enum**: `NamedTheme::Hume` · *Alias*: Hume

Two Black pieces belonging to a half-pin (or pin line) converge on the same square in a Grimshaw interference, allowing pin-mates.

```thema
key [A B]
where a.mutually_blocks(b, A, B),
  (a.self_pins_for(A) || b.self_pins_for(B)),
  (A.pin_mate || B.pin_mate)
subsumes DefencesOnSameSquare, Laitinen, PinMate, SelfPin
story "Hume theme: Key 1.{K}!{threat_clause}.
  Defenses 1...{a} and 1...{b} interfere and self-pin
  on {a.to}, allowing pin-mates 2.{A}# and 2.{B}#."
```

### Ojanen
**Enum**: `NamedTheme::Ojanen` · *Alias*: Ojanen theme

Two White sliders try moving to the same square (White Grimshaw) and are refuted by moves of the same Black Knight, which become Black correction variations after the key.

```thema
def [a:N b:N]
try Tr1 [! _]
try Tr2 [_ !]
key K [A B]
where Tr1.from != Tr2.from, Tr1.to == Tr2.to, Tr1.slider,
  Tr2.slider, same_piece(a, b), a.to != b.to
story "Ojanen: White Grimshaw tries 1.{Tr1}? and 1.{Tr2}?
  on {Tr1.to} are refuted by Knight moves 1...{a}!
  and 1...{b}!, which allow 2.{A}# and 2.{B}# after
  Key 1.{K}!."
```

### Paros
**Enum**: `NamedTheme::Paros` · *Alias*: Paros theme

Two Black Knights execute random and correction moves that open and close lines (Bivalve) while pinning or unguarding.

```thema
def [a:N b:N c:N d:N]
key [A B C D]
where same_piece(a, b), same_piece(c, d), a.from != c.from
story "Paros: Key 1.{K}!{threat_clause}.
  Correction pairs by two Black Knights (1...{a}/1...{b}
  and 1...{c}/1...{d}) produce 2.{A}#, 2.{B}#, 2.{C}#,
  and 2.{D}#."
```

### American Indian
**Enum**: `NamedTheme::AmericanIndian`

A White slider withdraws along a line behind another piece (or clears a line) while granting a capture flight or sacrificing a piece.

```thema
def [a:K:x b]
key K:Q|R|B [A B]
where (A.fires_battery || B.fires_battery
    || K.clears_line_for(A))
subsumes FlightCapture
story "American Indian: Slider Key 1.{K}!{threat_clause}
  withdraws along a line, granting capture flight
  1...{a} 2.{A}# and answering 1...{b} with 2.{B}#."
```

### Target Bristol
**Enum**: `NamedTheme::TargetBristol`

A White slider sacrifices itself on a square along a line, and when Black captures it, a second White slider traverses that same line to recapture on the exact same square.

```thema
def [a:x@K]
key K:Q|R|B [A:Q|R|B:x@K]
where K.clears_line_for(A)
subsumes Kozhakin, SacrificeBristol, ZeplerDoubling
story "Target Bristol: Slider Key 1.{K}! sacrifices
  on {K.to}; after 1...{a}, White's {A.role} traverses
  the cleared line to recapture on {K.to} with 2.{A}#."
```

### Sacrifice Bristol
**Enum**: `NamedTheme::SacrificeBristol`

A White slider executes a Bristol line clearance while sacrificing itself on its arrival square.

```thema
key K:Q|R|B [A:Q|R|B]
where K.sacrifice, K.clears_line_for(A)
subsumes ActiveSacrifice, BristolClearance
story "Sacrifice Bristol: Sacrificial
  Key 1.{K}!{threat_clause} clears the line for 2.{A}#
  after 1...{a}."
```

### Schnoebelen
**Enum**: `NamedTheme::Schnoebelen` · *Alias*: Schnoebelen theme

After tries with changed mates (Zagoruiko), the key sacrifices a White slider on an edge/corner square to clear a line (Bristol/Annihilation) for the White Queen.

```thema
try [A B]
key K:R|B [C:Q D:Q]
where K.clears_line_for(C)
subsumes BristolClearance, ChangedPlay
story "Schnoebelen: After Try 1.{Tr}? (2.{A}#, 2.{B}#),
  Key 1.{K}! clears the line for Queen mates 2.{C}#
  and 2.{D}#."
```

### Hess theme
**Enum**: `NamedTheme::Hess` · *Alias*: Hess

Two half-pinned Black Knights move to two shared destination squares, producing four distinct mates via self-pinning, self-interference, and bivalve play.

```thema
def [a:N b:N c:N d:N]
key [A B C D]
where same_piece(a, c), same_piece(b, d),
  a.from != b.from, same_square(a, b), same_square(c, d),
  a.to != c.to
subsumes BlackCorrection, DefencesOnSameSquare, Laitinen,
  Paros
story "Hess theme: Key 1.{K}!{threat_clause}. Two Black
  Knights converge on {a.to} (1...{a} 2.{A}#, 1...{b}
  2.{B}#) and {c.to} (1...{c} 2.{C}#, 1...{d} 2.{D}#)."
```

### Melnikov theme
**Enum**: `NamedTheme::Melnikov` · *Alias*: Melnikov

The key creates a half-pin, and a Grimshaw between a Black Rook and Bishop on that line indirectly self-unpins Black while allowing two distinct mates.

```thema
def [a:!x b:!x]
key K [A B]
where {a.role, b.role} == {'R', 'B'},
  a.mutually_blocks(b, A, B), K.half_pin,
  (a.unpins(BK) || b.unpins(BK))
subsumes DefencesOnSameSquare, Grimshaw, Laitinen
story "Melnikov theme: Key 1.{K}!{threat_clause} combines
  half-pin play with a Rook-Bishop Grimshaw on {a.to}
  (1...{a} 2.{A}#, 1...{b} 2.{B}#)."
```

### Support mate
**Enum**: `NamedTheme::SupportMate`

The key piece moves to guard a square directly adjacent to the Black King, and after a Black self-block or interference, a different White piece delivers a contact checkmate on that square.

```thema
key K [A B]
where A.from != K.to, distance(A.to, BK) == 1,
  K.guards(A.to), a.self_block
subsumes SelfBlock
story "Support mate: Key 1.{K}!{threat_clause} guards
  {A.to} so that after self-block 1...{a}, White delivers
  supported contact mate 2.{A}#."
```

### Leibovici
**Enum**: `NamedTheme::Leibovici` · *Alias*: Leibovici theme

A White Queen key moves along a pin line (Pelle move), and an English Grimshaw between the Black Queen and a Black Bishop/Rook on the same square allows distinct battery mates.

```thema
def [a:Q:!x b:B|R:!x]
key K:Q [A B]
where a.mutually_blocks(b, A, B),
  (A.fires_battery || B.fires_battery)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes BatteryMate, BatteryPlay, EnglishGrimshaw,
  Plachutta
story "Leibovici: Queen Key 1.{K}!{threat_clause}
  induces an English Grimshaw on {a.to} (1...{a} 2.{A}#,
  1...{b} 2.{B}#)."
```

### Peris theme
**Enum**: `NamedTheme::Peris` · *Alias*: Peris

A square-clearing key threatens mate on the vacated square while two Black slider checks combine Goethart unpinning and Levman interference.

```thema
def [a:B|R|Q:+ b:B|R|Q:+]
key K (T@K.from) [A B]
where a.from != b.from
subsumes ProvokedCheck
story "Peris theme: Key 1.{K}! clears {K.from} for threat
  2.{T}# and answers slider checks 1...{a} (2.{A}#) and
  1...{b} (2.{B}#)."
```

### Hochberger theme
**Enum**: `NamedTheme::Hochberger` · *Alias*: Hochberger

A White slider key moves along a line (Anti-Bristol / unpinning key) so that a Black Rook capturing the key piece with check is answered by a pawn recapture mate while other defenses allow the key piece to mate.

```thema
def [a:R:x@K:+ b]
key K:R|B|Q [A:P:x@K B]
where B.from == K.to
subsumes ActiveSacrifice, Kozhakin, ProvokedCheck
story "Hochberger theme: Slider Key 1.{K}!{threat_clause}
  answers checking capture 1...{a} with pawn recapture
  2.{A}# and 1...{b} with 2.{B}#."
```

### White Gamage
**Enum**: `NamedTheme::WhiteGamage`

Four tries by two White Rooks and two White Bishops to two intersection squares (doubled White Grimshaw) fail to Black captures/interferences before the key solves.

```thema
try Tr1:R [! _ _ _]
try Tr2:B [_ ! _ _]
try Tr3:R [_ _ ! _]
try Tr4:B [_ _ _ !]
where Tr1.to == Tr2.to, Tr3.to == Tr4.to, Tr1.to != Tr3.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes WhiteGrimshaw
story "White Gamage: Doubled White Grimshaw tries
  on {Tr1.to} (1.{Tr1}?, 1.{Tr2}?) and {Tr3.to} (1.{Tr3}?,
  1.{Tr4}?)."
---
try Tr1:R [! _]
try Tr2:B [_ !]
try Tr3:R [_ !]
try Tr4:B [_ !]
where Tr1.to == Tr2.to, Tr3.to == Tr4.to, Tr1.to != Tr3.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes WhiteGrimshaw
story "White Gamage: Doubled White Grimshaw tries
  on {Tr1.to} (1.{Tr1}?, 1.{Tr2}?) and {Tr3.to} (1.{Tr3}?,
  1.{Tr4}?)."
```

### Area clearkeeping
**Enum**: `NamedTheme::AreaClearkeeping` · *Alias*: Area clearing

Multiple waiting tries by the White King fail because the White King obstructs a White slider's mating line; the key moves the White King to the unique square that keeps all mating lines open.

```thema
try Tr1:K () [! _]
try Tr2:K () [_ !]
key K:K () [A:Q|R|B B:Q|R|B]
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to),
  (A.crosses(Tr1.to) || B.crosses(Tr1.to)
    || A.crosses(Tr2.to) || B.crosses(Tr2.to))
subsumes WhiteCorrection
story "Area clearkeeping: White King tries 1.{Tr1}? and
  1.{Tr2}? obstruct White's sliders; Key 1.{K}! keeps
  the lines clear for 2.{A}# and 2.{B}#."
```

### White Organ pipes
**Enum**: `NamedTheme::WhiteOrganPipes`

Two White Rooks and two White Bishops standing on the same rank or file execute four mutual line-opening/interference tries or mates.

```thema
any [A:R B:B C:R D:B]
where distinct(A.from, B.from, C.from, D.from),
  (same(A.from.rank, B.from.rank, C.from.rank,
    D.from.rank) || same(A.from.file, B.from.file,
    C.from.file, D.from.file))
story "White Organ pipes: Two White Rooks and two White
  Bishops aligned on a rank/file deliver 2.{A}#, 2.{B}#,
  2.{C}#, and 2.{D}#."
---
try Tr1:R [! _ _ _]
try Tr2:B [_ ! _ _]
try Tr3:R [_ _ ! _]
try Tr4:B [_ _ _ !]
where distinct(Tr1.from, Tr2.from, Tr3.from, Tr4.from),
  (same(Tr1.from.rank, Tr2.from.rank, Tr3.from.rank,
    Tr4.from.rank) || same(Tr1.from.file, Tr2.from.file,
    Tr3.from.file, Tr4.from.file))
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "White Organ pipes: Two White Rooks and two White
  Bishops aligned on a rank/file execute tries 1.{Tr1}?,
  1.{Tr2}?, 1.{Tr3}?, and 1.{Tr4}?."
---
try Tr1:B [! _]
try Tr2:R [_ !]
try Tr3:R [_ !]
try Tr4:B [_ !]
where distinct(Tr1.from, Tr2.from, Tr3.from, Tr4.from),
  (same(Tr1.from.rank, Tr2.from.rank, Tr3.from.rank,
    Tr4.from.rank) || same(Tr1.from.file, Tr2.from.file,
    Tr3.from.file, Tr4.from.file))
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "White Organ pipes: Two White Rooks and two White
  Bishops aligned on a rank/file execute tries 1.{Tr1}?,
  1.{Tr2}?, 1.{Tr3}?, and 1.{Tr4}?."
```

### Latvian Boros Plachutta
**Enum**: `NamedTheme::BorosPlachuttaLatvian`

Two like-moving Black sliders capture on two adjacent squares (one a flight square, reciprocal Boros Plachutta), producing four distinct mates.

```thema
def [a:R:x b:R:x c:R:x d:R:x]
key [A B C D]
where same_piece(a, c), same_piece(b, d),
  a.mutually_blocks(b, A, B), c.to == d.to, a.to != c.to,
  (a.flight_block || c.flight_block)
subsumes BorosPlachutta
story "Latvian Boros Plachutta: Key 1.{K}!{threat_clause}.
  Two Black Rooks capture on two squares {a.to} (1...{a}
  2.{A}#, 1...{b} 2.{B}#) and {c.to} (1...{c} 2.{C}#,
  1...{d} 2.{D}#)."
```

---

## 02. Pinning, Half-Pins & Unpinning Dynamics

*Pinning and unpinning mechanics, half-pins, third-pins, Goethart unpins, Schiffmann defenses, and self-pinning variations.*

### Schiffmann
**Enum**: `NamedTheme::Schiffmann` · *Alias*: Schiffmann Defense

A Black defense self-pins to the Black King or interposes on a pin line such that White's threat would unpin it; White checkmates by exploiting the pin.

```thema
key K (X) [A!@a]
where a.role != 'K', !is_pinned(a.from, before(a)),
  a.pinned_to(BK), a.self_pins_for(A),
  !is_pinned(a.to, after(X))
with -single_refutation -match_threat_count
  -capture_try_piece -match_mate_count
subsumes KingsSchiffmann
story "Schiffmann defense: Key 1.{K}! (threat 2.{X}#)
  The defense 1...{a} self-pins to defeat the threat,
  exploited by the checkmate 2.{A}#"
---
def [a:K]
key K (X) [A]
where a.self_pins_for(A), (A.fires_battery || A.pin_mate),
  (X.fires_battery || X.unpins(BK) || same_piece(X, A))
with -single_refutation -match_threat_count
  -capture_try_piece -match_mate_count
subsumes KingsSchiffmann
story "King's Schiffmann defense: Key 1.{K}!
  (threat 2.{X}#). The Black King 1...{a} pins a friendly
  piece to defeat the threat, exploited by 2.{A}#."
```

### Half-Pin
**Enum**: `NamedTheme::HalfPin`

Two Black pieces stand on a line to the Black King; when either moves off the line, the other becomes pinned.

```thema
any [A B]
where a.half_pin, collinear(a.from, b.from, BK),
  a.from != b.from, (a, b).pins(BK)
with -match_mate_count -capture_try_piece
  -single_refutation
story "Half-pin: Key 1.{K}!{threat_clause} exploits the
  half-pin of the Black pieces on {a.from} and {b.from}:
  moving one leaves the other pinned (1...{a} 2.{A}#
  vs 1...{b} 2.{B}#)."
---
any [A]
where a.half_pin, a.pins(BK), A.pin_mate
with -match_mate_count -capture_try_piece
  -single_refutation
story "Half-pin: Defense 1...{a} leaves its companion
  pinned to the Black King, exploited by pin-mate 2.{A}#."
```

### White Half-Pin
**Enum**: `NamedTheme::WhiteHalfPin`

Two White pieces stand on a line to the White King; moving one leaves the other pinned.

```thema
any K
where K.white_half_pin
with -capture_try_piece -single_refutation
story "White half-pin: Move 1.{K} moves one of two White
  half-pinned pieces, leaving the other pinned while
  unleashing checkmate."
---
any [A]
where A.white_half_pin
with -match_mate_count -capture_try_piece
  -single_refutation
story "White half-pin: Mate 2.{A}# after 1...{a}
  moves one of two White half-pinned pieces, leaving
  the other pinned."
```

### Pin Mate
**Enum**: `NamedTheme::PinMate`

Checkmate where a Black defending piece is pinned to the Black King.

```thema
any [A]
where A.pin_mate
story "Pin-mate: Key 1.{K}!{threat_clause}.
  Defense 1...{a} is met by checkmate 2.{A}# exploiting
  an absolute pin against Black."
---
key (T)
where T.pin_mate
story "Pin-mate: Key 1.{K}! threatens checkmate 2.{T}#
  exploiting an absolute pin against Black."
```

### Gamage
**Enum**: `NamedTheme::Gamage` · *Alias*: Gamage theme

Black self-blocks on a square that self-pins another Black piece or interferes with White.

```thema
key [A]
where a.unpins(A),
  (a.pins(a.to) || (collinear(a.from, A.from, WK)
    && (a.self_block || a.capture)))
story "Gamage theme: Key 1.{K}!{threat_clause}.
  Defense 1...{a} self-pins, enabling White to exploit
  the pin with checkmate 2.{A}#."
---
key [A]
where A.unpins(BK), A.slider,
  (a.closes_line() || a.self_block)
story "Gamage theme: Key 1.{K}!{threat_clause}.
  Defense 1...{a} obstructs a pinned Black piece, allowing
  the pinning {A.role_name} to deliver checkmate 2.{A}#."
```

### Mansfield
**Enum**: `NamedTheme::Mansfield` · *Alias*: Mansfield theme

Black defense pins a White piece, but White uses a battery to mate while unpinning.

```thema
key [A]
where A.from.pinned_to(WK)
story "Mansfield: Key 1.{K}!{threat_clause}.
  Black defense 1...{a} pins a White piece, but White uses
  a battery to mate while unpinning: 2.{A}#."
---
def [a:x b:x]
key [A B]
where same_square(a, b), a.from != b.from,
  A.fires_battery, B.fires_battery, a.self_pins_for(A),
  b.self_pins_for(B)
story "Mansfield: Key 1.{K}!{threat_clause}.
  Two Black pieces capture on {a.to} and self-pin,
  answered by distinct battery mates: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Barulin
**Enum**: `NamedTheme::Barulin` · *Alias*: Barulin theme

Defense self-pins and White mates by self-unpinning or battery.

```thema
key [A B]
where same_square(A, B), A.from != B.from
subsumes MatesOnSameSquare
story "Barulin: Key 1.{K}!{threat_clause}.
  Defenses 1...{a} and 1...{b} unpin White pieces,
  allowing checkmates 2.{A}# and 2.{B}#."
```

### Pelle move
**Enum**: `NamedTheme::Pelle` · *Alias*: Pelle

A pinned White piece moves along its pin line without capturing the pinning Black piece.

```thema
key [A]
where A.pinned_before, A.pinned_after, A.along(WK)
story "Pelle move: Key 1.{K}!{threat_clause}.
  Pinned {A.role_name} on {A.from} moves along the pin
  line to deliver checkmate 2.{A}# after 1...{a}."
---
key (A)
where A.pinned_before, A.pinned_after, A.along(WK)
with -match_threat_count
story "Pelle move: Key 1.{K}! threatens checkmate 2.{A}#
  by the pinned {A.role_name} on {A.from} moving along
  the pin line."
---
key K
where K.pinned_before, K.pinned_after, K.along(WK)
story "Pelle move: Key 1.{K}!{threat_clause} moves the
  pinned {K.role_name} on {K.from} along the pin line."
```

### Self-unpinning
**Enum**: `NamedTheme::SelfUnpinning`

A defending piece unpins a friendly piece by moving off the pin line.

```thema
key [A]
where a.unpins(BK)
story "Self-unpinning: Key 1.{K}!{threat_clause}.
  Black defense 1...{a} unpins a friendly piece,
  met by checkmate 2.{A}#."
```

### Half-pin creation
**Enum**: `NamedTheme::HalfPinCreation`

White key creates or unmasks a half-pin arrangement of two Black pieces.

```thema
key K
where K.creates_half_pin
story "Half-pin creation: Key 1.{K}!{threat_clause}
  creates a half-pin on the line to the Black King."
```

### Direct unpinning
**Enum**: `NamedTheme::DirectUnpinning`

White or Black directly moves off the pin line to relieve a pinned piece.

```thema
key K [A]
where (a.unpins(A) && !collinear(a.to, A.from, WK))
    || K.unpins_piece(A.from)
story "Direct unpinning: Key 1.{K}!{threat_clause} unpins
  a piece to enable checkmate 2.{A}# against 1...{a}."
---
key K [A B]
where same_piece(a, b), K.unpins_piece(a.from)
with -match_mate_count
story "Direct unpinning: Key 1.{K}!{threat_clause}
  directly unpins Black's {a.role_name} on {a.from},
  whose defenses 1...{a} and 1...{b} are met by 2.{A}#
  and 2.{B}#."
```

### Indirect unpinning
**Enum**: `NamedTheme::IndirectUnpinning`

Unpinning achieved by interposing on the pin line or moving the King.

```thema
key [A]
where a.unpins(A), collinear(a.to, A.from, WK),
  !collinear(a.from, A.from, WK)
story "Indirect unpinning: Key 1.{K}!{threat_clause}.
  Defense 1...{a} interposes on a pin line, unpinning
  the White piece to deliver mate 2.{A}#."
---
any K [A]
where K.unpins(WK) || (K.unpins(BK) && (!K.slider
    || K.closes_line(BK))) || (a.role != 'K'
    && a.unpins(BK))
story "Indirect unpinning: Play features indirect
  unpinning by interposition on the pin line
  (1...{a} 2.{A}#)."
```

### Self-pin
**Enum**: `NamedTheme::SelfPin`

A defending or attacking piece moves so as to pin a friendly piece.

```thema
key K [A]
where K.pins(WK) || a.self_pins_for(A)
story "Self-pin: Key 1.{K}!{threat_clause} features
  self-pinning play (1...{a} 2.{A}#)."
```

### Pin
**Enum**: `NamedTheme::Pin`

A piece is pinned along a line of action to its King.

```thema
key K
where false
story "Pinning key: Key 1.{K}! establishes a pin against
  a Black piece."
```

### Unpin
**Enum**: `NamedTheme::Unpin`

A piece is released from a pin by moving off the line or interposing.

```thema
key [A]
where a.unpins(A)
subsumes DirectUnpinning
story "Unpinning mate: Key 1.{K}!{threat_clause} answers
  defense 1...{a} with checkmate 2.{A}# by exploiting
  an unpinned piece."
```

### Selfpinning
**Enum**: `NamedTheme::Selfpinning`

Black moves in such a way as to expose its own piece to a pin.

```thema
key [A]
where a.self_pins_for(A)
subsumes SelfPin
story "Self-pinning defense: Key 1.{K}!{threat_clause}
  induces defense 1...{a} which self-pins a Black piece,
  allowing checkmate 2.{A}#."
```

### Indirect selfpinning
**Enum**: `NamedTheme::IndirectSelfpinning`

Black King moves or another piece vacates a square, leaving a friendly piece pinned.

```thema
key K [A]
where (a.indirect_pins(BK) && a.self_pins_for(A))
    || K.indirect_pins(WK) || (K.from == a.to
    && a.pinned_to(BK) && a.self_pins_for(A))
story "Indirect self-pinning: Key 1.{K}!{threat_clause}
  induces defense 1...{a} which indirectly self-pins,
  enabling checkmate 2.{A}#."
```

### Third-pin
**Enum**: `NamedTheme::ThirdPin`

A third pin is created or exploited in the solution.

```thema
^key [A* B* C*]
where distinct(a.from, b.from, c.from), a.to < b.to,
  b.to < c.to, (a.pinned_to(BK) || a.pins(BK)),
  (b.pinned_to(BK) || b.pins(BK)),
  (c.pinned_to(BK) || c.pins(BK))
with -match_mate_count
subsumes SelfPin
story "Third-pin: Key 1.{K}!{threat_clause} exploits three
  Black units pinned across variations: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Pinning key
**Enum**: `NamedTheme::PinningKey`

White key directly pins a Black defending piece.

```thema
key K
where K.pins(BK)
story "Pinning key: Key 1.{K}!{threat_clause} pins
  an enemy unit to paralyze its defense."
```

### Nietvelt
**Enum**: `NamedTheme::Nietvelt` · *Alias*: Nietvelt defense

Black defense self-pins to the King such that White threat would unpin; White mates by exploiting the pin.

```thema
key K [A!@a]
where K.threat_count > 0, a.role != 'K', a.pinned_to(BK),
  a.self_pins_for(A)
with -match_mate_count -capture_try_piece
  -single_refutation
story "Nietvelt: Defense 1...{a} self-pins, answered
  by checkmate 2.{A}# exploiting the pinned unit."
```

### Unpinning key
**Enum**: `NamedTheme::UnpinningKey`

White key unpins a Black defending piece or a White piece.

```thema
key K
where K.unpins(WK) || K.unpins(BK)
story "Unpinning key: Key 1.{K}!{threat_clause} directly
  unpins a piece."
---
key K [A B]
where same_piece(a, b), K.unpins_piece(a.from)
with -match_mate_count
story "Unpinning key: Key 1.{K}!{threat_clause} directly
  unpins Black's {a.role_name} on {a.from}."
---
key K [A]
where K.unpins_piece(a.from)
with -match_mate_count
story "Unpinning key: Key 1.{K}!{threat_clause}
  directly unpins Black's {a.role_name} on {a.from}
  (1...{a} 2.{A}#)."
```

### Double pin
**Enum**: `NamedTheme::DoublePin`

Two pieces are simultaneously pinned, or a single piece is pinned along two intersecting lines.

```thema
key K [A]
where K.double_pin || a.double_pin
story "Double pin: Key 1.{K}!{threat_clause} meets
  defense 1...{a} with checkmate 2.{A}# exploiting two
  simultaneously pinned units."
```

### Self-pinning key
**Enum**: `NamedTheme::SelfPinningKey`

White key pins one of White's own pieces to the White King.

```thema
key K
where K.pins(WK)
story "Self-pinning key: Key 1.{K}!{threat_clause}
  self-pins a White piece to craft an airtight
  mating net."
```

### Pin-unpin
**Enum**: `NamedTheme::PinUnpin`

A move simultaneously pins one piece while unpinning another.

```thema
set [A B]
key [C D]
where (a.unpins(WK) || a.pins(WK)),
  (b.unpins(WK) || b.pins(WK))
subsumes FreeChange
story "Pin-unpin: Changed play with pinning and
  unpinning of pieces relative to the White King:
  1...{a} set 2.{A}# / key 2.{C}#, 1...{b} set 2.{B}# /
  key 2.{D}# (Key 1.{K}!{threat_clause})."
```

### Hage
**Enum**: `NamedTheme::Hage` · *Alias*: Hage theme

Key move creates a battery while simultaneously pinning a Black piece, or delivers a double pin-mate.

```thema
key K [A]
where K.pins(BK), A.pins(BK)
subsumes PinningKey
story "Hage: Key 1.{K}!{threat_clause} creates a battery
  while pinning a Black piece; 1...{a} 2.{A}#."
---
key [A*]
where A.double_pin
with -match_mate_count
story "Hage: Key 1.{K}!{threat_clause} leads to double
  pin-mate: 1...{a} 2.{A}#."
```

### Indirect pinning
**Enum**: `NamedTheme::IndirectPinning`

A pin established not directly against the King, but revealed after another piece moves.

```thema
^key K [A* B*]
where (K.indirect_pins(BK) && (A.pin_mate || B.pin_mate))
    || (a.indirect_pins(BK) && a.self_pins_for(A))
    || a.indirect_pins(WK)
with -match_mate_count
subsumes IndirectSelfpinning
story "Indirect pinning: Key 1.{K}!{threat_clause}
  unmasks a pin across defenses: 1...{a} 2.{A}#
  vs 1...{b} 2.{B}#."
```

### Anti-Goethart
**Enum**: `NamedTheme::AntiGoethart`

Inversion of Goethart: Black defense opens a line to refute a Goethart unpinning threat, or battery play interacts with pin/unpin lines.

```thema
def [a:!K b:!K]
key K [A B]
where (A, B).fires_battery, same_piece(A, B),
  (a.unpins(A) || b.unpins(B) || a.unpins(BK)
    || b.unpins(BK) || A.unpins(BK) || B.unpins(BK)
    || a.from.pinned_to(BK) || b.from.pinned_to(BK)
    || A.closes_line(BK) || B.closes_line(BK)
    || a.closes_line() || b.closes_line()
    || a.closes_line(WK) || b.closes_line(WK)
    || (K.threat_count > 0 && (A.closes_line(WK)
    || B.closes_line(WK))))
story "Anti-Goethart: Key 1.{K}!{threat_clause} fires
  the {A.role_name} battery across pin/interposition
  lines: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
def [a:!K b:!K]
key (X) [A B]
where X.unpins(BK),
  (a.opens_line() || b.opens_line() || a.unpins(BK)
    || b.unpins(BK))
with -match_threat_count -match_mate_count
story "Anti-Goethart: Key 1.{K}! threatens
  Goethart mate 2.{X}# (unpinning a Black piece);
  1...{a} and 1...{b} open lines against the threat,
  allowing 2.{A}# and 2.{B}#."
```

### Somov (B2)
**Enum**: `NamedTheme::SomovB2`

Somov theme form B2: Black correction defense allows mate through unpinning of White piece.

```thema
key (T) [T B]
where same_piece(a, b), a.to != b.to, b.unpins(B)
subsumes ThreatKey, Unpin
story "Somov B2: Key 1.{K}! threatens 2.{T}# following
  general defense 1...{a}; corrected defense 1...{b}
  unpins a White piece to allow checkmate 2.{B}#."
---
key [A A B]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  c.unpins(B)
subsumes Unpin
story "Somov B2: Key 1.{K}!{threat_clause} meets
  general defenses 1...{a} and 1...{b} with 2.{A}#;
  corrected defense 1...{c} unpins a White piece to allow
  checkmate 2.{B}#."
```

### Mansfield battery
**Enum**: `NamedTheme::MansfieldBattery`

A White battery fires distinct checkmates against two Black pieces defending on the same square (Mansfield couplet), across two batteries, or with pin/self-pin play.

```thema
key [A B]
where (A, B).fires_battery,
  ((!same_piece(a, b) && (same_square(a, b)
    || A.battery_rear != B.battery_rear
    || A.from != B.from || a.self_pins || b.self_pins
    || a.pins(BK) || b.pins(BK))) || ((a, b).role == 'K'
    && a != b && same_piece(A, B)))
with -match_threat_count -match_mate_count
subsumes BatteryPlay
story "Mansfield battery: Key 1.{K}!{threat_clause} fires
  battery checkmates 2.{A}# (against 1...{a}) and 2.{B}#
  (against 1...{b})."
```

### Rupp theme
**Enum**: `NamedTheme::Rupp`

Pin-status alteration of both White and Black pieces.

```thema
key [A]
where a.closes_line(WK), a.unpins(A),
  !collinear(a.from, A.from, WK), a.pins(BK)
story "Rupp theme: Key 1.{K}!{threat_clause} answers
  defense 1...{a} with checkmate 2.{A}# by exploiting
  the unpinned White piece."
---
key K [A]
where (K.pins(BK) || K.unpins(BK)),
  (K.pins(WK) || K.unpins(WK))
story "Rupp theme: Key 1.{K}!{threat_clause}
  simultaneously alters White and Black pin lines,
  leading to 2.{A}# against 1...{a}."
```

### Ajec theme
**Enum**: `NamedTheme::Ajec`

Two Black pieces (including the Black Queen) stand in a half-pin at distance >= 3 from the Black King; when either moves off the line, the other becomes pinned.

```thema
key [A B]
where a.half_pin, (a.role == 'Q' || b.role == 'Q'),
  collinear(a.from, b.from, BK), a.from != b.from,
  (distance(a.from, BK) >= 3
    || distance(b.from, BK) >= 3),
  (a, b).pins(BK)
subsumes HalfPin, IndirectSelfpinning, SelfPin
story "Ajec theme: Key 1.{K}!{threat_clause} provokes
  self-pinning defenses that allow checkmates:
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Somov (B1)
**Enum**: `NamedTheme::SomovB1`

Black correction defense whose secondary flaw is direct unpinning of a White piece.

```thema
def [r a]
key (T) [T A]
where a.corrects(r), a.parries(T), a.unpins(A)
subsumes ThreatKey
story "Somov (B1): After Key 1.{K}! (threat 2.{T}#),
  random move 1...{r} allows 2.{T}#, while Black
  correction 1...{a} directly unpins a White piece
  for 2.{A}#."
```

### Somov (D)
**Enum**: `NamedTheme::SomovD`

Black correction defense whose secondary flaw is pinning a Black piece or self-pinning.

```thema
def [r a]
key (T) [T A]
where a.corrects(r), a.parries(T), a.self_pins_for(A)
subsumes CrossCheck, ProvokedCheck, SelfPin, ThreatKey
story "Somov (D): After Key 1.{K}! (threat 2.{T}#), random
  move 1...{r} allows 2.{T}#, while Black correction
  1...{a} creates a Black pin exploited by 2.{A}#."
```

### Correction with unpin
**Enum**: `NamedTheme::CorrectionUnpin`

White correction between a try and the key where the correcting key move simultaneously unpins a piece.

```thema
try Tr (X) [! _]
key K (Y) [A B]
where same_piece(Tr, K), (K.unpins(WK) || K.unpins(BK))
subsumes ChangedMate, DirectUnpinning, ThreatKey,
  UnpinningKey
story "Correction with unpin: White {K.role_name} try
  1.{Tr}? is corrected by Key 1.{K}! (threat 2.{Y}#),
  which unpins a piece for 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Anticipatory pinning
**Enum**: `NamedTheme::AnticipatoryPinning`

White key sets up a pin or indirect pin in advance, exploited by pin-mates when Black defends.

```thema
key K [A B]
where K.indirect_pins() && (A.pin_mate || B.pin_mate)
subsumes PinMate
story "Anticipatory pinning: Key 1.{K}!{threat_clause}
  prepares an anticipatory pin line exploited
  by 1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
key K:Q|R|B [A]
where !collinear(K.from, a.to, BK),
  collinear(K.to, a.to, BK), a.self_pins_for(A),
  A.pin_mate
subsumes PinMate
story "Anticipatory pinning: Key 1.{K}!{threat_clause}
  moves onto the pin line through {BK}, so 1...{a}
  self-pins and allows pin-mate 2.{A}#."
```

### Anticipatory half-pin
**Enum**: `NamedTheme::AnticipatoryHalfPin`

White key creates a half-pin formation, and both Black half-pinned pieces move to allow pin-mates.

```thema
key K [A B]
where K.creates_half_pin, (a, b).pins(BK), (A, B).pin_mate
subsumes DoublePinMate, HalfPinCreation,
  IndirectSelfpinning, SelfPin
story "Anticipatory half-pin: Key 1.{K}!{threat_clause}
  establishes a half-pin line, yielding pin-mates after
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Masked half-pin
**Enum**: `NamedTheme::MaskedHalfPin`

The White key piece moves off a line containing two Black pieces and the Black King, unmasking a half-pin.

```thema
key K [A B]
where K.from != A.from, collinear(K.from, a.from, BK),
  collinear(K.from, b.from, BK),
  !collinear(K.to, a.from, BK), a.from != b.from,
  (a, b).pins(BK)
story "Masked half-pin: Key 1.{K}!{threat_clause} vacates
  {K.from} to unmask a half-pin on {a.from} and {b.from}:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Double direct unpinning
**Enum**: `NamedTheme::DoubleDirectUnpinning`

Two distinct Black defenses directly unpin White piece(s) by moving the pinning piece or capturing.

```thema
key [A B]
where a.unpins_piece(A.from), b.unpins_piece(B.from),
  !between(a.to, WK, A.from), !between(b.to, WK, B.from)
subsumes Unpin
story "Double direct unpinning: After
  Key 1.{K}!{threat_clause}, Black defenses 1...{a} and
  1...{b} directly unpin White for 2.{A}# and 2.{B}#."
```

### Double indirect unpinning
**Enum**: `NamedTheme::DoubleIndirectUnpinning`

Two distinct Black defenses interpose along a pin-line to the White King, indirectly unpinning White for two different checkmates.

```thema
key [A B]
where a.unpins_piece(A.from), b.unpins_piece(B.from),
  between(a.to, WK, A.from), between(b.to, WK, B.from)
subsumes Unpin
story "Double indirect unpinning: After
  Key 1.{K}!{threat_clause}, Black defenses 1...{a} and
  1...{b} interpose to unpin White for 2.{A}# and 2.{B}#."
```

### Cross-pinning
**Enum**: `NamedTheme::CrossPinning`

A Black defense unpins a White piece while simultaneously pinning a Black piece, allowing a pin-mate by the unpinned White piece.

```thema
key [A]
where a.unpins_piece(A.from), a.pins(BK), A.pin_mate
subsumes PinMate, Unpin
story "Cross-pinning: After Key 1.{K}!{threat_clause},
  defense 1...{a} unpins White's {A.role_name} on {A.from}
  while pinning a Black unit, allowing pin-mate 2.{A}#."
```

### Reciprocal unpinning
**Enum**: `NamedTheme::ReciprocalUnpinning`

Two different White pieces are unpinned in two variations (defense a unpins piece A which mates; defense b unpins piece B which mates).

```thema
key [A B]
where diff_piece(A, B), a.unpins_piece(A.from),
  b.unpins_piece(B.from)
subsumes Unpin
story "Reciprocal unpinning: After
  Key 1.{K}!{threat_clause}, 1...{a} unpins {A.from} for
  2.{A}#, while 1...{b} unpins {B.from} for 2.{B}#."
```

### Royal half-pin
**Enum**: `NamedTheme::RoyalHalfPin`

White half-pin formation in which the White King participates in delivering one of the mates.

```thema
key [A B]
where K.white_half_pin, (A.role == 'K' || B.role == 'K')
story "Royal half-pin: Key 1.{K}!{threat_clause}
  features a White half-pin with Royal participation:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Unpinning cross-check
**Enum**: `NamedTheme::UnpinCrossCheck`

A Black checking defense simultaneously unpins a White piece, which delivers a non-capturing cross-check mate.

```thema
def [a:+]
key [A!@a]
where a.unpins_piece(A.from)
story "Unpinning cross-check:
  After Key 1.{K}!{threat_clause}, Black check
  1...{a} unpins White's {A.role_name} on {A.from} for
  cross-check 2.{A}#."
```

### Double pin-mate
**Enum**: `NamedTheme::DoublePinMate`

At least two distinct defensive variations end in pin-mates.

```thema
key [A B]
where (A, B).pin_mate, a.self_pins_for(A),
  b.self_pins_for(B), a.to != b.to
subsumes PinMate
story "Double pin-mate: Key 1.{K}!{threat_clause}
  produces two distinct pin-mates: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Triple pin-mate
**Enum**: `NamedTheme::TriplePinMate`

At least three distinct defensive variations end in pin-mates.

```thema
key [A B C]
where (A, B, C).pin_mate, a.self_pins_for(A),
  b.self_pins_for(B), c.self_pins_for(C),
  distinct(a.to, b.to, c.to)
subsumes DoublePinMate
story "Triple pin-mate: Key 1.{K}!{threat_clause}
  produces three distinct pin-mates: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, and 1...{c} 2.{C}#."
```

### Theme C
**Enum**: `NamedTheme::ThemeC` · *Alias*: Thema C

Two Black sliders move to two shared arrival squares, indirectly pinning one of two White pieces so the other delivers mate on the same square.

```thema
key [A B]
where a.slider, b.slider, a.from != b.from,
  A.from != B.from, A.to == B.to,
  (a.pins(WK) || b.pins(WK) || a.closes_line()
    || b.closes_line())
subsumes Barulin
story "Theme C: Key 1.{K}!{threat_clause}.
  Defenses 1...{a} and 1...{b} separate White's pieces
  on the same mating square {A.to}: 2.{A}# vs 2.{B}#."
```

### Theme D
**Enum**: `NamedTheme::ThemeD` · *Alias*: Thema D

Two moves of the same Black slider pin one of two White pieces in turn, forcing the other unpinned White piece to deliver mate on the same square.

```thema
key [A B]
where same_piece(a, b), a.slider, a.to != b.to,
  A.from != B.from, A.to == B.to,
  (a.pins(WK) || b.pins(WK))
subsumes Barulin
story "Theme D: Key 1.{K}!{threat_clause}. Moves 1...{a}
  and 1...{b} by the same Black {a.role} force distinct
  White pieces to mate on {A.to}: 2.{A}# vs 2.{B}#."
```

### Roels
**Enum**: `NamedTheme::Roels` · *Alias*: Roels theme

Black defenses open a White line or battery while unpinning/closing a Black guard, enabling the same White slider to deliver distinct mates along its line.

```thema
key [A B C]
where same_piece(A, B, C), A.slider,
  distinct(A.to, B.to, C.to), a.unpins(A), b.unpins(B),
  (a.opens_line() || a.closes_line() || a.ep)
story "Roels: Key 1.{K}!{threat_clause}. Defenses 1...{a},
  1...{b}, and 1...{c} allow the same White {A.role}
  to mate on {A.to}, {B.to}, and {C.to}."
```

### Weenink
**Enum**: `NamedTheme::Weenink` · *Alias*: Weenink theme

Two Black sliders move to the same square, where one closes a White line (Java) while unpinning or unguarding to separate two White mates.

```thema
key [A B]
where same_square(a, b), a.from != b.from, a.slider,
  b.slider,
  (a.unpins(WK) || b.unpins(WK) || a.closes_line(WK)
    || b.closes_line(WK))
subsumes DefencesOnSameSquare, Laitinen
story "Weenink: Key 1.{K}!{threat_clause}.
  Slider defenses 1...{a} and 1...{b} on {a.to} separate
  2.{A}# and 2.{B}#."
```

### Cristoffanini
**Enum**: `NamedTheme::Cristoffanini` · *Alias*: Cristoffanini theme

A Black defense leaves a line to indirectly pin another Black piece or interposes to self-pin while opening/closing a line, allowing mate exploiting the pin.

```thema
key [A B]
where same_piece(a, b), a.to != b.to, A != B,
  a.self_pins_for(A), b.self_pins_for(B), a.closes_line(),
  b.closes_line()
story "Cristoffanini: Key 1.{K}!{threat_clause}.
  Moves 1...{a} and 1...{b} self-pin or unmask an indirect
  pin on a Black piece while closing a line, allowing
  2.{A}# and 2.{B}#."
---
key [A B]
where a.from != b.from, A != B, a.self_pins_for(A),
  b.self_pins_for(B), same_square(a, b),
  (a.closes_line() || b.closes_line())
subsumes SelfPin
story "Cristoffanini: Key 1.{K}!{threat_clause}.
  Defenses 1...{a} and 1...{b} self-pin by interposing
  on {a.to}, allowing 2.{A}# and 2.{B}#."
```

### Costachel
**Enum**: `NamedTheme::Costachel` · *Alias*: Costachel theme

Three Black pieces (including the Black King or two sliders) move to or capture on the same square, combining Cristoffanini indirect pinning with self-block.

```thema
key [A B C]
where same_square(a, b, c),
  distinct(a.from, b.from, c.from),
  (a.indirect_pins(BK) || b.indirect_pins(BK)
    || c.indirect_pins(BK)),
  (a.self_block || b.self_block || c.self_block)
subsumes ArrivalCorrection
story "Costachel: Key 1.{K}!{threat_clause}.
  Three Black pieces converge on {a.to} (1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#) with indirect pinning
  and self-block."
```

### Möller theme
**Enum**: `NamedTheme::Moeller` · *Alias*: Moeller theme

Moves of the Black Queen indirectly unpin a White piece or indirectly pin a Black piece while separating dual mates.

```thema
def [a:Q b:Q]
key [A B]
where same_piece(a, b), a.to != b.to,
  (a.indirect_pins(BK) || b.indirect_pins(BK)
    || a.unpins(WK) || b.unpins(WK))
story "Möller theme: Key 1.{K}!{threat_clause}.
  Black Queen moves 1...{a} and 1...{b} alter pin lines
  to separate 2.{A}# and 2.{B}#."
```

### Taale theme
**Enum**: `NamedTheme::Taale`

The key creates a masked battery and half-pin while provoking a Black check that is answered by the key piece firing the battery.

```thema
def [a:+ b]
key K [A B]
where A.from == K.to, A.fires_battery,
  (a.unpins(WK) || b.self_pins || B.fires_battery)
subsumes BatteryMate, BatteryPlay, CrossCheck,
  ProvokedCheck
story "Taale theme: Key 1.{K}!{threat_clause} creates
  a masked battery and provokes 1...{a}, answered
  by battery mate 2.{A}# (with 1...{b} 2.{B}#)."
```

### Schiffmann 2
**Enum**: `NamedTheme::Schiffmann2` · *Alias*: Schiffmann II

A Black piece captures a White piece without giving check, self-pinning on that square so White can abandon guard and mate by exploiting the self-pin.

```thema
def [a:x:!+]
key [A]
where a.role != 'K', a.pinned_to(BK), a.self_pins_for(A),
  A.to != a.to, A.pin_mate
subsumes PinMate, SelfPin
story "Schiffmann 2: Key 1.{K}!{threat_clause}.
  Non-checking capture 1...{a} self-pins on {a.to},
  enabling pin-mate 2.{A}#."
```

### King's Schiffmann
**Enum**: `NamedTheme::KingsSchiffmann` · *Alias*: King Schiffmann

The Black King moves to a flight square (or captures), exposing a Black piece to a pin so that White's threat would unpin it, and White delivers a battery/pin mate.

```thema
def [a:K]
key K (X) [A]
where a.self_pins_for(A), (A.fires_battery || A.pin_mate),
  (X.fires_battery || X.unpins(BK) || same_piece(X, A))
subsumes KingFlight
story "King's Schiffmann: Key 1.{K}!{threat_clause}. Black
  King flight 1...{a} enables battery/pin-mate 2.{A}#."
```

### White Schiffmann
**Enum**: `NamedTheme::WhiteSchiffmann`

White correction tries by a piece that captures on a square where Black's recapture pins or unpins, resolved by a different piece capturing on that square in the key.

```thema
try Tr1 [! _]
try Tr2:x [A !]
key K:x [B C]
where same_piece(Tr1, Tr2), Tr2.to == K.to,
  Tr1.from != K.from
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes CaptureKey, ChangedPlay, Sushkov
story "White Schiffmann: Tries 1.{Tr1}? and 1.{Tr2}?
  on {K.to} are resolved by capture Key 1.{K}!,
  yielding 2.{B}# and 2.{C}#."
```

### Schór theme
**Enum**: `NamedTheme::Schor` · *Alias*: Schor theme

White key captures a Black piece to directly unpin another Black piece while simultaneously creating a half-pin or indirect pin.

```thema
key K:x [A B]
where K.unpins(BK),
  (a.self_pins || b.self_pins || A.pin_mate || B.pin_mate)
subsumes CaptureKey, DirectUnpinning, UnpinningKey
story "Schór theme: Capture Key 1.{K}!{threat_clause}
  unpins a Black piece while setting up pin-play after
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Ianovcic
**Enum**: `NamedTheme::Ianovcic` · *Alias*: Ianovcic theme

Key move alters the pin status of both White and Black pieces (Rupp) while creating a half-pin where Black defenses indirectly self-pin.

```thema
key K [A B]
where (K.pins(BK) || K.unpins(WK) || K.unpins(BK)),
  (a.self_pins_for(A) || b.self_pins_for(B))
subsumes SelfPin
story "Ianovcic: Key 1.{K}!{threat_clause} changes pin
  lines so 1...{a} and 1...{b} self-pin, allowing 2.{A}#
  and 2.{B}#."
```

### Castellari
**Enum**: `NamedTheme::Castellari` · *Alias*: Castellari theme

The key move self-pins a White piece, and Black's defense unpins that White piece to allow checkmate.

```thema
key K [A]
where K.pins(WK), a.unpins(WK), A.from != K.to
story "Castellari: Self-pinning Key 1.{K}!{threat_clause}
  is followed by 1...{a} unpinning for 2.{A}#."
```

### Castellari-Mari theme
**Enum**: `NamedTheme::CastellariMari`

A White King key move unpins a Black piece (or self-unpins), whose checking defense is answered by a White cross-check mate.

```thema
def [a:+]
key K:K [A]
where K.unpins(BK) || K.unpins(WK) || a.self_pins
    || a.unpins(WK)
subsumes ProvokedCheck
story "Castellari-Mari theme: White King
  Key 1.{K}!{threat_clause} alters pin lines and answers
  check 1...{a} with 2.{A}#."
```

### Castellari-Schor theme
**Enum**: `NamedTheme::CastellariSchor`

The key move simultaneously unpins a Black piece and self-pins/unpins a White piece, producing distinct pin/unpin variations.

```thema
key K [A B]
where (K.unpins(BK) || K.pins(BK)),
  (K.pins(WK) || K.unpins(WK))
story "Castellari-Schor theme: Key 1.{K}!{threat_clause}
  simultaneously changes White and Black pin status,
  leading to 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Dobbs
**Enum**: `NamedTheme::Dobbs` · *Alias*: Dobbs theme

Two Black checking captures indirectly unpin a White piece (or self-pin) to allow two distinct cross-check recaptures.

```thema
def [a:x:+ b:x:+]
key [A:x@a B:x@b]
where a.from != b.from,
  (a.unpins(WK) || b.unpins(WK) || a.self_pins
    || b.self_pins)
subsumes ProvokedCheck
story "Dobbs: Key 1.{K}!{threat_clause}.
  Checking captures 1...{a} and 1...{b} unpin/self-pin,
  answered by recaptures 2.{A}# and 2.{B}#."
```

### Tuxen theme
**Enum**: `NamedTheme::Tuxen` · *Alias*: Tuxen

In set play a Black checking capture is answered by recapture; the key moves the White piece so that the same Black checking capture self-pins and is answered by a non-capturing cross-check pin-mate.

```thema
def [a:x:+]
vir [A:x@a]
key [B:!x]
where B.pin_mate || a.self_pins
subsumes ChangedCrossCheck, CrossCheck, ProvokedCheck
story "Tuxen theme: Set recapture 1...{a} 2.{A}# changes
  after Key 1.{K}! to non-capturing cross-check pin-mate
  1...{a} 2.{B}#."
```

### Anti-Hume
**Enum**: `NamedTheme::AntiHume`

Two half-pinned Black pieces move to the same square, each leaving the other pinned so two different White pieces can capture on that square without duals.

```thema
key [A:x@a B:x@b]
where same_square(a, b), a.from != b.from,
  A.from != B.from,
  (a.self_pins_for(A) || b.self_pins_for(B)),
  (A.pin_mate || B.pin_mate)
subsumes Barulin, Hume, IndirectSelfpinning
story "Anti-Hume: Key 1.{K}!{threat_clause}.
  Half-pin defenses 1...{a} and 1...{b} on {a.to} allow
  distinct White captures 2.{A}# and 2.{B}#."
```

### Anti-Gamage
**Enum**: `NamedTheme::AntiGamage`

Moves of a Black slider along or off a pin line combine Gamage unpinning with Black correction and self-block.

```thema
def [a:B|R|Q b:B|R|Q c:B|R|Q]
key [A B C]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  (a.unpins(WK) || b.unpins(WK) || c.unpins(WK)),
  (a.self_block || b.self_block || c.self_block)
story "Anti-Gamage: Key 1.{K}!{threat_clause}.
  Slider moves 1...{a} (2.{A}#), 1...{b} (2.{B}#),
  and 1...{c} (2.{C}#) combine unpinning and self-block."
```

### Anti-Rupp
**Enum**: `NamedTheme::AntiRupp`

The key move simultaneously unpins both a White piece and a Black piece, the inverse of the Rupp theme.

```thema
key K [A B]
where K.unpins(WK), K.unpins(BK)
subsumes CastellariSchor, DirectUnpinning,
  IndirectUnpinning, Rupp, UnpinningKey
story "Anti-Rupp: Key 1.{K}!{threat_clause} simultaneously
  unpins a White and a Black piece to allow 1...{a} 2.{A}#
  and 1...{b} 2.{B}#."
```

### Anti-Hassberg
**Enum**: `NamedTheme::AntiHassberg`

The key move self-pins a White piece, and moves of a Black piece unpin that White piece (or allow pin/unpin variations).

```thema
def [a:N b:N]
key K [A B]
where K.pins(WK), same_piece(a, b), a.to != b.to,
  (a.unpins(WK) || b.unpins(WK))
story "Anti-Hassberg: Self-pinning
  Key 1.{K}!{threat_clause} induces Black Knight unpinning
  defenses 1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Hassberg theme
**Enum**: `NamedTheme::Hassberg` · *Alias*: Hassberg

Key K unpins a Black piece, whose capture defense a allows the key piece to deliver switchback mate A.

```thema
def [a:x]
key K [A]
where K.unpins(BK), A.switchback(K)
with -match_threat_count -match_mate_count
subsumes Switchback, Unpinning
story "Hassberg theme: Key 1.{K}!{threat_clause} unpins
  a Black piece, whose capture 1...{a} allows the key
  piece to switchback with 2.{A}#."
```

### Mikulcak theme
**Enum**: `NamedTheme::Mikulcak` · *Alias*: Mikulcak

White correction tries by an unpinning piece change threats (threat correction) and transfer variation mates into the key.

```thema
try Tr1 (X) [A !]
try Tr2 (Y) [B _]
key K (Z) [_ A]
where same_piece(Tr1, Tr2, K)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay, ThreatKey
story "Mikulcak theme: White correction tries 1.{Tr1}?
  (threat 2.{X}#; 1...{a} 2.{A}#) and 1.{Tr2}?
  (threat 2.{Y}#) transfer 2.{A}# into Key 1.{K}!
  (threat 2.{Z}#; 1...{b} 2.{A}#)."
```

### Mousetrap
**Enum**: `NamedTheme::Mousetrap` · *Alias*: Mousetrap theme

A flight-giving or unpinning key by a front battery piece allows a Black slider to move along a line, whereupon the key piece switches back (or captures) to shut the trap with a battery mate.

```thema
def [a:Q|R|B b:Q|R|B]
key K [A B]
where same_piece(a, b), A.from == K.to, B.from == K.to,
  (A.switchback(K) || B.switchback(K)),
  (A.fires_battery || B.fires_battery)
subsumes SwitchbackBatteryMate
story "Mousetrap: Key 1.{K}!{threat_clause} lures Black's
  {a.role} (1...{a}, 1...{b}) and springs the battery trap
  with 2.{A}# and 2.{B}#."
```

### Klasinc theme
**Enum**: `NamedTheme::Klasinc` · *Alias*: Klasinc

An unpinning, flight-giving key exposes the White Queen to capture by a Black Bishop/slider, answered by the key piece switching back or capturing on the line (Mousetrap + passive Queen sacrifice).

```thema
def [a:x b]
key K [A~K B:x@b]
where same_piece(a, b), B.from == K.to,
  (A.fires_battery || B.fires_battery)
subsumes BatteryMate, BatteryPlay, Switchback
story "Klasinc theme: Key 1.{K}!{threat_clause} exposes
  a White piece to 1...{a} (answered by switchback 2.{A}#)
  and answers 1...{b} with 2.{B}#."
```

### Lahti theme
**Enum**: `NamedTheme::Lahti` · *Alias*: Lahti

An unpinning key by a White Rook/slider along a line creates a masked battery, and two moves of the unpinned Black Queen/slider are answered by the key piece stepping along the line.

```thema
def [a:Q|R|B b:Q|R|B]
key K:R|B|Q [A B]
where K.unpins(BK), same_piece(a, b), a.to != b.to,
  A.from == K.to, B.from == K.to, A.to != B.to
subsumes DirectUnpinning, UnpinningKey
story "Lahti theme: Unpinning slider
  Key 1.{K}!{threat_clause} answers moves of the unpinned
  Black {a.role} (1...{a}, 1...{b}) with 2.{A}#
  and 2.{B}#."
```

### Four-Pin-Way theme
**Enum**: `NamedTheme::FourPinWay`

Two Black pieces on two half-pin lines make four moves that self-pin and unpin, producing four distinct pin-mates.

```thema
key [A B C D]
where same_piece(a, b), same_piece(c, d),
  a.from != c.from,
  (a.self_pins_for(A) || b.self_pins_for(B)),
  (c.self_pins_for(C) || d.self_pins_for(D))
subsumes SelfPin
story "Four-Pin-Way theme: Key 1.{K}!{threat_clause}.
  Two half-pinned Black pieces (1...{a}/1...{b} and
  1...{c}/1...{d}) produce four pin-play variations:
  2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
```

### Servais theme
**Enum**: `NamedTheme::Servais` · *Alias*: Servais

A White Queen/slider key creates a half-pin by moving along a line, and defenses by the two half-pinned Black pieces on adjacent squares allow mates by the key piece and another piece.

```thema
key K:Q|R|B [A B]
where a.from != b.from, a.self_pins_for(A),
  b.self_pins_for(B), A.from == K.to, B.from != K.to
subsumes SelfPin
story "Servais theme: Slider Key 1.{K}!{threat_clause}
  creates a half-pin; defenses 1...{a} and 1...{b} allow
  2.{A}# (by the key piece) and 2.{B}#."
```

### Loyd half-pin
**Enum**: `NamedTheme::LoydHalfPin`

A waiting ambush key by a White slider sets up a masked half-pin of two Black Knights on the same line.

```thema
def [a:N b:N]
key K:Q|R|B () [A B]
where a.from != b.from,
  (a.self_pins_for(A) || b.self_pins_for(B))
subsumes SelfPin
story "Loyd half-pin: Waiting ambush Key 1.{K}! sets up
  a half-pin of two Black Knights (1...{a} 2.{A}# and
  1...{b} 2.{B}#)."
```

### Arguelles
**Enum**: `NamedTheme::Arguelles` · *Alias*: Arguelles theme

A Black Knight in a half-pin executes random and correction moves that self-pin the companion piece while opening/closing lines, forcing three distinct White mates.

```thema
def [a:N b:N c:N]
key [A B C]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  (a.self_pins_for(A) || b.self_pins_for(B)
    || c.self_pins_for(C))
subsumes SelfPin
story "Arguelles: Key 1.{K}!{threat_clause}. A half-pinned
  Black Knight executes correction moves 1...{a} (2.{A}#),
  1...{b} (2.{B}#), and 1...{c} (2.{C}#)."
```

### Dawson
**Enum**: `NamedTheme::Dawson` · *Alias*: Dawson theme

A square-clearing key vacates a square for a White mate while two half-pinned Black sliders self-interfere and self-pin.

```thema
key K [A B C]
where A.to == K.from, b.slider, c.slider,
  b.from != c.from, (b.self_pins || c.self_pins)
subsumes SelfPin
story "Dawson: Key 1.{K}!{threat_clause} clears {K.from}
  for 1...{a} 2.{A}# while half-pinned sliders 1...{b} and
  1...{c} allow 2.{B}# and 2.{C}#."
```

### Wigwag
**Enum**: `NamedTheme::Wigwag` · *Alias*: Wigwag theme

A Black Bishop and a Black Knight in a half-pin both move to the same square, each self-blocking and leaving the other pinned to allow two distinct White mates.

```thema
def [a:B b:N]
key [A B]
where same_square(a, b), a.self_block,
  (a.self_pins_for(A) || b.self_pins_for(B))
subsumes DefencesOnSameSquare, Laitinen, SelfBlock,
  SelfPin
story "Wigwag: Key 1.{K}!{threat_clause}. Half-pinned
  Bishop 1...{a} and Knight 1...{b} self-block on {a.to},
  allowing 2.{A}# and 2.{B}#."
```

### Martin theme
**Enum**: `NamedTheme::Martin` · *Alias*: Martin

One-step and two-step advances of a Black pawn close two different Black lines while unpinning or self-pinning, forcing two distinct White Knight/battery mates.

```thema
def [a:P b:P]
key [A B]
where same_piece(a, b), a.one_step, b.two_step,
  (a.closes_line() || b.closes_line()),
  (a.self_pins || b.self_pins || a.unpins(WK)
    || b.unpins(WK) || A.pin_mate || B.pin_mate)
subsumes LineClosure, SelfInterference
story "Martin theme: Key 1.{K}!{threat_clause}.
  Pawn one-step 1...{a} (2.{A}#) and two-step 1...{b}
  (2.{B}#) close lines and alter pin lines."
```

### Anti-Somov A2
**Enum**: `NamedTheme::AntiSomovA2`

Two Black Knights move to the same square, each indirectly unpinning a White piece while closing a Black line to separate two White mates.

```thema
def [a:N b:N]
key [A B]
where same_square(a, b), a.from != b.from, a.unpins(WK),
  b.unpins(WK), a.closes_line(), b.closes_line()
subsumes DefencesOnSameSquare, Laitinen
story "Anti-Somov A2: Key 1.{K}!{threat_clause}.
  Two Black Knights moving to {a.to} (1...{a} and 1...{b})
  unpin and close lines to force 2.{A}# and 2.{B}#."
```

### Hagemann theme
**Enum**: `NamedTheme::Hagemann` · *Alias*: Hagemann

A White key creates a half-battery or half-pin configuration where two Black defenses self-pin on two lines, allowing double pin-mates.

```thema
key K [A B]
where a.from != b.from, a.self_pins_for(A),
  b.self_pins_for(B), A.pin_mate, B.pin_mate
subsumes DoublePinMate, SelfPin
story "Hagemann theme: Key 1.{K}!{threat_clause}
  induces self-pinning defenses 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Monitor theme
**Enum**: `NamedTheme::Monitor` · *Alias*: Pin-unpin Restoration

The key pins a Black piece, and two Black slider defenses on the same square restore or transfer the pin while allowing paired mates.

```thema
key K [A B]
where K.pins(BK), same_square(a, b), a.from != b.from,
  a.slider, b.slider
subsumes DefencesOnSameSquare, Laitinen, PinningKey
story "Monitor theme: Pinning Key 1.{K}!{threat_clause}
  induces slider defenses 1...{a} and 1...{b} on {a.to},
  answered by 2.{A}# and 2.{B}#."
```

### Hirlap theme
**Enum**: `NamedTheme::Hirlap` · *Alias*: Hirlap

A sacrificial key creates a half-pin, and moves of the half-pinned Black sliders transfer the set-play mates to new defenses.

```thema
vir [A B _ _]
key K [_ _ A B]
where K.sacrifice, c.slider, d.slider
subsumes ActiveSacrifice
story "Hirlap theme: Set mates 2.{A}# and 2.{B}# are
  transferred after sacrificial Key 1.{K}! to half-pin
  defenses 1...{c} 2.{A}# and 1...{d} 2.{B}#."
```

### Larceu theme
**Enum**: `NamedTheme::Larceu` · *Alias*: Larceu

A White King key move changes the pin status (Rupp) and provokes a Black check that indirectly self-pins and is answered by an Umnov cross-check.

```thema
def [a:+ b]
key K:K [A@a.from B]
where (a.self_pins || b.self_pins || K.pins(BK)
    || K.unpins(WK))
subsumes PseudoUmnov1
story "Larceu theme: White King Key 1.{K}!{threat_clause}
  provokes check 1...{a} (self-pinning for Umnov
  cross-check 2.{A}#) and answers 1...{b} with 2.{B}#."
```

### Howard
**Enum**: `NamedTheme::Howard` · *Alias*: Howard theme

A pinned White line-piece moves along the pin line to unpin a Black piece, which in turn moves onto the pin line to unpin the White piece for two distinct mates.

```thema
def [a b]
key K:Q|R|B [A B]
where collinear(WK, K.from, K.to), K.unpins(BK),
  a.unpins(WK), b.unpins(WK), a.to != b.to,
  A.from == K.to, B.from == K.to, A.to != B.to
subsumes DirectUnpinning, UnpinningKey
story "Howard: Pinned Key 1.{K}!{threat_clause} moves
  along the pin line to unpin Black, and defenses 1...{a}
  and 1...{b} unpin 1.{K} for mates 2.{A}# and 2.{B}#."
```

### Bograd
**Enum**: `NamedTheme::Bograd` · *Alias*: Bograd theme

A White King key move unpins the White Queen, which then delivers at least four distinct pin-mates against Black defenses.

```thema
key K:K [A:Q B:Q]
where K.unpins(WK), same_piece(A, B), A.to != B.to,
  (A.pin_mate || B.pin_mate)
subsumes DirectUnpinning, IndirectUnpinning, PinMate,
  SelfPin, UnpinningKey
story "Bograd: White King Key 1.{K}!{threat_clause} unpins
  the White Queen, which delivers pin-mates 1...{a} 2.{A}#
  and 1...{b} 2.{B}#."
```

### Gavrilov Pickaninny
**Enum**: `NamedTheme::GavrilovPickaninny`

A Black pawn executes Pickaninny defenses (one-step, two-step, and captures) that self-interfere and allow White pin-mates.

```thema
def [a:P b:P c:P]
key [A B C]
where same_piece(a, b, c), a.one_step, b.two_step,
  (A.pin_mate || B.pin_mate || C.pin_mate)
story "Gavrilov Pickaninny: Key 1.{K}!{threat_clause}.
  Black's pawn on {a.from} makes Pickaninny defenses
  (1...{a}, 1...{b}, 1...{c}) allowing pin-mates 2.{A}#,
  2.{B}#, and 2.{C}#."
```

### Pawnee theme
**Enum**: `NamedTheme::Pawnee` · *Alias*: Pawnee

A waiting pawn key unpins a Black Rook/slider, whose moves along its line allow a White pawn to deliver at least three Albino-style pawn mates.

```thema
def [a:R|B|Q b:R|B|Q c:R|B|Q]
key K:P () [A:P B:P C:P]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  same_piece(A, B, C), distinct(A.to, B.to, C.to)
subsumes Duel
story "Pawnee theme: Waiting pawn Key 1.{K}! unpins
  Black's {a.role} (1...{a}, 1...{b}, 1...{c}),
  answered by pawn mates 2.{A}#, 2.{B}#, and 2.{C}#."
```

### Barulin 1
**Enum**: `NamedTheme::Barulin1`

Two moves of the Black Queen pin one of two White Rooks in turn, forcing the other Rook to deliver checkmate on the exact same square.

```thema
def [a:Q b:Q]
key [A:R B:R]
where same_piece(a, b), a.to != b.to, A.from != B.from,
  A.to == B.to, (a.pins(WK) || b.pins(WK))
subsumes AntiDual, ThemeD
story "Barulin 1: Key 1.{K}!{threat_clause}.
  Black Queen moves 1...{a} and 1...{b} pin one White
  Rook in turn, forcing the other Rook to mate on {A.to}:
  2.{A}# vs 2.{B}#."
```

### Barulin 2
**Enum**: `NamedTheme::Barulin2`

A sacrificial square-clearing key provokes two checks by the same Black Rook along a line, answered by a White Knight interposing on two squares (including the square vacated by the key).

```thema
def [a:R:+ b:R:+]
key K [A:N B:N]
where same_piece(a, b), a.to != b.to, same_piece(A, B),
  A.to != B.to, (A.to == K.from || B.to == K.from)
subsumes CrossCheck, ProvokedCheck
story "Barulin 2: Key 1.{K}!{threat_clause} clears
  {K.from} and provokes Rook checks 1...{a} (2.{A}#) and
  1...{b} (2.{B}#)."
```

### Barulin (B2)
**Enum**: `NamedTheme::BarulinB2` · *Alias*: Barulin B2

Set play has mates A, B against two Black defenses; a flight-giving key changes those mates so two different defenses allow the same changed mate while the new flight allows a third mate.

```thema
def [a b c:K]
vir [A B _]
key K [B C D]
where K.flights_given >= 1
subsumes ChangedMate, FlightGivingKey, KingFlight,
  TransferredMates
story "Barulin (B2): Flight-giving Key
  1.{K}!{threat_clause} changes set play (1...{a} 2.{A}#,
  1...{b} 2.{B}#) to 1...{a} 2.{B}#, 1...{b} 2.{C}#,
  and flight 1...{c} 2.{D}#."
```

### Mackenzie
**Enum**: `NamedTheme::Mackenzie` · *Alias*: Mackenzie theme

Two Black Knights capture the key piece on K.to, each self-pinning or unguarding so a White battery fires to capture the other Knight on its departure square.

```thema
def [a:N:x@K b:N:x@K]
key K [A B]
where a.from != b.from, A.to == b.from, B.to == a.from,
  (A.fires_battery || B.fires_battery)
subsumes BatteryMate, BatteryPlay, DoubleSacrificeKey
story "Mackenzie: Sacrificial Key 1.{K}!{threat_clause}
  on {K.to} is captured by Knights 1...{a} and 1...{b},
  answered by battery captures on each other's origin:
  2.{A}# and 2.{B}#."
```

### Ventura theme
**Enum**: `NamedTheme::Ventura` · *Alias*: Ventura

A White Knight try fails to two Black pawn pushes; the key moves that Knight onto one of the pawns' squares (Rupp/self-block) so the other pawn push indirectly self-pins and allows mate.

```thema
def [a:P b:P]
try Tr:N [! !]
key K:N [A -]
where same_piece(Tr, K), K.to == b.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes SelfPin
story "Ventura theme: Knight try 1.{Tr}? fails to pawn
  moves 1...{a}! and 1...{b}!; Key 1.{K}! blocks {b.to} so
  1...{a} allows 2.{A}#."
```

### Jönsson cycle
**Enum**: `NamedTheme::JonssonCycle` · *Alias*: Jonsson cycle

Three Black defenses create a cycle of indirect pins and indirect unpins, forcing three distinct White checkmates.

```thema
key [A B C]
where (a.indirect_pins(BK) || a.unpins(WK)),
  (b.indirect_pins(BK) || b.unpins(WK)),
  (c.indirect_pins(BK) || c.unpins(WK)),
  (a.indirect_pins(BK) || b.indirect_pins(BK)
    || c.indirect_pins(BK)),
  (a.unpins(WK) || b.unpins(WK) || c.unpins(WK))
story "Jönsson cycle: Key 1.{K}!{threat_clause}. Defenses
  1...{a} (2.{A}#), 1...{b} (2.{B}#), and 1...{c} (2.{C}#)
  combine indirect pinning and indirect unpinning."
```

### Buenos-Aires theme
**Enum**: `NamedTheme::BuenosAires`

A threat key creates a battery or half-pin configuration where Black defenses unpin or self-pin to allow distinct White battery mates.

```thema
key K (T) [A B]
where (a.unpins(A) || b.unpins(B) || a.self_pins_for(A)
    || b.self_pins_for(B)),
  A.fires_battery, B.fires_battery
subsumes BatteryPlay
story "Buenos-Aires theme: Key 1.{K}! (threat 2.{T}#)
  produces battery mates 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Onitiu theme
**Enum**: `NamedTheme::Onitiu` · *Alias*: Onitiu

A Black King move (typically to a flight square granted by the key) self-pins Black pieces along lines radiating from the new King square, allowing a multiple pin-mate.

```thema
def [a:K]
key K [A]
where K.flights_given >= 1, a.self_pins_for(A), A.pin_mate
subsumes FlightGivingKey, PinMate, SelfPin
story "Onitiu theme: Flight-giving Key
  1.{K}!{threat_clause} allows Black King flight 1...{a},
  which self-pins Black's defenses for pin-mate 2.{A}#."
---
def [a:N b:N c:N]
key K:P:x [A:N B:N C:N]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  (A.pin_mate || B.pin_mate || C.pin_mate)
subsumes CaptureKey
story "Onitiu theme: Pawn capture
  Key 1.{K}!{threat_clause} induces Black Knight defenses
  1...{a}, 1...{b}, and 1...{c}, answered by Knight mates
  2.{A}#, 2.{B}#, and 2.{C}#."
```

### Monreal Peugeot theme
**Enum**: `NamedTheme::MonrealPeugeot`

After a flight-giving King key, two Black sliders capture on the same square and self-pin (Mansfield), allowing the same White Knight to capture each slider's departure square.

```thema
def [a:Q|R|B:x b:Q|R|B:x]
key K:K [A:N B:N]
where same_square(a, b), a.from != b.from,
  same_piece(A, B), A.to == b.from, B.to == a.from
subsumes DefencesOnSameSquare, Laitinen, Mansfield
story "Monreal Peugeot theme: King
  Key 1.{K}!{threat_clause}. Captures 1...{a} and 1...{b}
  on {a.to} self-pin, allowing White's Knight to mate
  on {b.from} (2.{A}#) and {a.from} (2.{B}#)."
```

### King's Nietvelt
**Enum**: `NamedTheme::KingsNietvelt`

In set play, a Black King flight allows mate A; the key grants a new King flight so the original flight allows changed mate B while the new flight transfers mate A.

```thema
def [a:K b:K]
vir [A -]
key K [B A]
where a.to != b.to
subsumes ChangedMate, KingFlight, TransferredMates
story "King's Nietvelt: Set flight 1...{a} 2.{A}# changes
  after Key 1.{K}! to 1...{a} 2.{B}#, while new flight
  1...{b} transfers 2.{A}#."
```

### Michel theme
**Enum**: `NamedTheme::Michel` · *Alias*: Michel

Two tries and the key by the same White Knight create a masked half-pin and indirectly unpin a White piece.

```thema
try Tr1:N [A ! _]
try Tr2:N [! _ B]
key K:N [A C _]
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to),
  (a.unpins(WK) || b.unpins(WK) || a.self_pins
    || b.self_pins)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedMate, SelfPin
story "Michel theme: White Knight tries 1.{Tr1}? and
  1.{Tr2}? lead to Knight Key 1.{K}! (1...{a} 2.{A}#,
  1...{b} 2.{C}#)."
---
try Tr1:N (X) [A !]
try Tr2:N (Y) [_ B]
key K:N (Z) [C D]
where same_piece(Tr1, Tr2, K),
  (a.unpins(WK) || b.unpins(WK) || a.self_pins
    || b.self_pins)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedMate, SelfPin
story "Michel theme: White Knight tries 1.{Tr1}? (threat
  2.{X}#) and 1.{Tr2}? (threat 2.{Y}#) lead to Knight Key
  1.{K}! (threat 2.{Z}#; 1...{a} 2.{C}#, 1...{b} 2.{D}#)."
```

### Bouttier
**Enum**: `NamedTheme::Bouttier` · *Alias*: Bouttier theme

A sacrificial key by a White Bishop/Rook pins a Black Knight; if the Black Queen captures the key piece she abandons guard of the back rank, while if the Knight moves (when unpinned) another Rook mates.

```thema
def [a:Q:x@K b:N]
key K:B|R [A:R B:R]
where A.from != B.from
subsumes ActiveSacrifice
story "Bouttier: Sacrificial Key 1.{K}!{threat_clause}
  on {K.to}; Queen capture 1...{a} allows 2.{A}# while
  Knight defense 1...{b} allows 2.{B}#."
```

---

## 03. Batteries & Discovered Checks

*White battery formations, direct, indirect, masked, half-batteries, and king battery discovery mates.*

### Half-battery
**Enum**: `NamedTheme::HalfBattery`

Two White pieces stand between a White line-piece and the Black King; either piece can move to fire the battery.

```thema
key K [A]
where A.fires_battery, A.from != K.to,
  between(K.from, A.battery_rear, BK),
  !collinear(A.battery_rear, BK, K.to)
story "Half-battery: Key 1.{K}!{threat_clause}.
  Either of two White pieces on the battery line can fire
  checkmate 2.{A}# against 1...{a}."
---
key K (A)
where A.fires_battery, A.from != K.to,
  between(K.from, A.battery_rear, BK),
  !collinear(A.battery_rear, BK, K.to)
with -match_threat_count
story "Half-battery: Key 1.{K}! unmasks the half-battery
  to threaten discovered checkmate 2.{A}#."
```

### Battery creation
**Enum**: `NamedTheme::BatteryCreation`

White key creates a direct or indirect battery.

```thema
key K [A]
where A.fires_battery,
  (K.to == A.from
    && !collinear(A.battery_rear, BK, K.from))
    || (K.to == A.battery_rear
    && !collinear(K.from, A.from, BK))
    || (between(K.from, A.battery_rear, BK)
    && !collinear(A.battery_rear, BK, K.to))
story "Battery creation: Key 1.{K}!{threat_clause} sets
  up a direct firing battery aimed at the Black King
  (1...{a} 2.{A}#)."
---
key K (A)
where A.fires_battery,
  (K.to == A.from
    && !collinear(A.battery_rear, BK, K.from))
    || (K.to == A.battery_rear
    && !collinear(K.from, A.from, BK))
    || (between(K.from, A.battery_rear, BK)
    && !collinear(A.battery_rear, BK, K.to))
with -match_threat_count
story "Battery creation: Key 1.{K}! sets up a direct
  firing battery threatening 2.{A}#."
---
try Tr [A]
key K
where same_piece(Tr, K), A.fires_battery,
  between(K.from, A.battery_rear, BK),
  !collinear(A.battery_rear, BK, K.to)
story "Battery creation: Key 1.{K}!{threat_clause} unmasks
  a direct firing battery aimed at the Black King."
```

### Royal battery
**Enum**: `NamedTheme::RoyalBattery`

A battery where the White King is the front (moving) piece delivering mate by discovery.

```thema
any [A:K]
where A.fires_battery
subsumes BatteryPlay, KingsBattery
story "Royal battery: Key 1.{K}!{threat_clause}.
  The White King itself steps aside to unmask discovered
  checkmate 2.{A}#."
```

### Battery mate
**Enum**: `NamedTheme::BatteryMate`

Checkmate is delivered by uncovered check from a battery.

```thema
any [A*]
where A.fires_battery
with -match_mate_count
story "Battery checkmate: Key 1.{K}!{threat_clause}.
  White fires the battery with 2.{A}# to deliver
  discovered checkmate."
---
any (A)
where A.fires_battery
with -match_threat_count
story "Battery checkmate: Key 1.{K}! threatens discovered
  battery checkmate 2.{A}#."
```

### Ellerman
**Enum**: `NamedTheme::Ellerman`

Key active sacrifice of a White piece sets up battery play, answered by multiple defenses met by battery mates.

```thema
key K:N|B|R|Q [A B]
where !K.capture, K.active_sacrifice, K.to != A.from,
  K.to != B.from, !between(K.from, A.battery_rear, BK),
  (A, B).fires_battery, A.battery_rear == B.battery_rear,
  A.battery_rear != K.to, a.from != b.from
with -match_mate_count
subsumes ActiveSacrifice, BatteryMate, BatteryPlay
story "Ellerman: Key 1.{K}!{threat_clause} creates
  a half-battery; defenses 1...{a} and 1...{b} fire
  checkmates 2.{A}# and 2.{B}#."
---
key K:N|B|R|Q (T) [A]
where !K.capture, K.active_sacrifice, K.to != T.from,
  K.to != A.from, !between(K.from, T.battery_rear, BK),
  (T, A).fires_battery, T.battery_rear == A.battery_rear,
  T.battery_rear != K.to
with -match_mate_count
subsumes ActiveSacrifice, BatteryMate, BatteryPlay
story "Ellerman: Key 1.{K}! (threat 2.{T}#) sacrifices
  on {K.to}; defense 1...{a} fires battery mate 2.{A}#."
```

### Siers battery
**Enum**: `NamedTheme::SiersBattery`

A battery where the front piece (a Knight) fires the battery on move 1 and mates on move 2, or mates after a King flight unmasks the rear battery piece.

```thema
key K:N [A:N]
where K.fires_battery, A.from == K.to, A.to != K.from
subsumes BatteryPlay
story "Siers battery: Knight 1.{K}+! fires the battery
  on move 1 and follows up with checkmate 2.{A}#
  against 1...{a}."
---
def [a:K]
key [A:N]
where !A.fires_battery, A.battery_rear >= 0,
  between(A.from, A.battery_rear, a.from)
subsumes IndirectBattery
story "Siers battery: After King flight 1...{a},
  front Knight 2.{A}# delivers checkmate while unmasking
  the rear battery piece on {a.from}."
```

### Battery play
**Enum**: `NamedTheme::BatteryPlay`

Checkmates delivered by battery fire across variations.

```thema
any [A]
where A.fires_battery
story "Battery play: Key 1.{K}!{threat_clause}
  leads to checkmate 2.{A}# by battery fire against
  defense 1...{a}."
```

### Battery
**Enum**: `NamedTheme::Battery`

A checkmate delivered by firing a battery (front piece moves, uncovering check from rear piece).

```thema
key K
where false
story "Battery: Checkmate delivered by firing a battery
  after Key 1.{K}!."
```

### Battery destruction
**Enum**: `NamedTheme::BatteryDestruction`

White key moves the rear piece or front piece off the battery line, dismantling it.

```thema
vir [A]
key K
where !K.check, A.fires_battery,
  (K.from == A.battery_rear
    && !collinear(A.from, BK, K.to)) || (K.from == A.from
    && !collinear(A.battery_rear, BK, K.to))
story "Battery destruction: Key 1.{K}!{threat_clause}
  disbands the {phase1} battery (1...{a} 2.{A}#)
  to construct a new mating net."
---
key K
where !K.check, K.destroys_battery
story "Battery destruction: Key 1.{K}!{threat_clause}
  disbands an existing battery to construct a new
  mating net."
```

### Half-battery creation
**Enum**: `NamedTheme::HalfBatteryCreation`

White key move sets up a half-battery configuration.

```thema
def [a:x]
key K [A]
where !collinear(K.from, a.to, BK),
  (A.fires_battery && ((between(a.to, A.battery_rear, BK)
    && K.to in {a.to, A.from, A.battery_rear})
    || (a.role == 'K' && a.to == K.to
    && between(A.from, A.battery_rear, a.to))))
    || (A.pins(a.to) && collinear(A.from, a.to, BK)
    && (K.to == a.to || K.to == A.from
    || between(a.to, K.to, BK)))
story "Half-battery creation: Key 1.{K}!{threat_clause}
  prepares a half-battery to deliver checkmate 2.{A}#
  against 1...{a}."
```

### Zabunov
**Enum**: `NamedTheme::Zabunov` · *Alias*: Zabunov theme

White key creates a battery formation that fires checkmate against a King flight.

```thema
def [a:K]
key K [A]
where A.fires_battery,
  (K.to == A.from
    && !collinear(A.battery_rear, BK, K.from))
    || (K.to == A.battery_rear
    && !collinear(K.from, A.from, BK))
    || (between(K.from, A.battery_rear, BK)
    && !collinear(A.battery_rear, BK, K.to))
subsumes BatteryCreation, BatteryMate, BatteryPlay,
  KingFlight
story "Zabunov: Key 1.{K}!{threat_clause} sets up a direct
  battery that fires checkmate 2.{A}# against King
  flight 1...{a}."
```

### Battery transformation
**Enum**: `NamedTheme::BatteryTransformation`

White transforms one battery line into a new battery line.

```thema
vir [X]
key K [A]
where A != X, A.fires_battery,
  (X.fires_battery || K.from == X.from),
  (A.from != X.from || A.battery_rear != X.battery_rear)
subsumes BatteryMate, BatteryPlay
story "Battery transformation: Key 1.{K}!{threat_clause}
  transforms an existing battery into a new firing line
  for 2.{A}# against 1...{a}."
---
key K [A]
where A.fires_battery,
  (between(K.from, K.battery_rear, BK)
    && (A.from != K.from
    || A.battery_rear != K.battery_rear))
    || (between(K.battery_front, K.from, BK)
    && (A.from != K.battery_front
    || A.battery_rear != K.from))
subsumes BatteryMate, BatteryPlay
story "Battery transformation: Key 1.{K}!{threat_clause}
  transforms an existing battery into a new firing line
  for 2.{A}# against 1...{a}."
```

### Indirect battery
**Enum**: `NamedTheme::IndirectBattery`

A battery pointing not at the Black King directly, but at a flight square in the King's field.

```thema
key [A]
where A.battery_rear >= 0,
  (!A.fires_battery
    || !collinear(A.battery_rear, A.from, BK))
story "Indirect battery: Key 1.{K}!{threat_clause} leads
  to battery fire along an indirect axis to seal checkmate
  2.{A}# against 1...{a}."
```

### Anti-battery
**Enum**: `NamedTheme::AntiBattery`

Black defense attacks or steps onto the battery line, preventing its fire, and is met by a non-recapture mate.

```thema
def [b a]
key K [B A]
where B.fires_battery, !A.fires_battery, !A.recaptures(a),
  a.to != K.to,
  (a.to == B.from || a.to == B.battery_rear
    || between(a.to, B.battery_rear, BK))
story "Anti-battery: Key 1.{K}!{threat_clause} meets
  defense 1...{a} which disrupts the battery line,
  answered by checkmate 2.{A}#."
---
key K (B) [A]
where B.fires_battery, !A.fires_battery, !A.recaptures(a),
  a.to != K.to,
  (a.to == B.from || a.to == B.battery_rear
    || between(a.to, B.battery_rear, BK))
with -match_threat_count
story "Anti-battery: Key 1.{K}!{threat_clause} meets
  defense 1...{a} which disrupts the battery line,
  answered by checkmate 2.{A}#."
```

### King's battery
**Enum**: `NamedTheme::KingsBattery`

Discovery mate delivered or threatened by the White King stepping off a line.

```thema
any [A:K]
with -single_refutation -capture_try_piece
  -match_mate_count
story "King's battery: Key 1.{K}!{threat_clause} is
  followed by the White King personally unmasking
  discovered checkmate 2.{A}# against 1...{a}."
---
any (T:K)
with -single_refutation -capture_try_piece
  -match_threat_count
story "King's battery: 1.{K} threatens discovered
  checkmate 2.{T}# by the White King."
```

### Masked battery
**Enum**: `NamedTheme::MaskedBattery`

A White battery is initially masked by a Black piece; when that Black piece moves off the line, the White battery fires to deliver checkmate.

```thema
def [a]
key [A]
where a.opens_line(A), A.fires_battery
subsumes BatteryMate, BatteryPlay
story "Masked battery: After Key 1.{K}!{threat_clause},
  Black defense 1...{a} unmasks the White battery,
  which fires with 2.{A}#."
```

### Popandopulo batteries
**Enum**: `NamedTheme::PopandopuloBatteries`

Two distinct White battery front pieces fire across variations to deliver discovered checkmates.

```thema
key [A B]
where diff_piece(A, B), (A, B).fires_battery
subsumes BatteryMate, BatteryPlay
story "Popandopulo batteries: Two distinct White
  batteries fire after Key 1.{K}!{threat_clause}:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Royal cross-check
**Enum**: `NamedTheme::RoyalCrossCheck`

A Black checking defense is answered by a discovered checkmate executed by the White King.

```thema
def [a:+]
key [A:K]
where A.fires_battery
subsumes CrossCheck, ProvokedCheck, RoyalBattery
story "Royal cross-check: After Key 1.{K}!{threat_clause},
  Black check 1...{a} is answered by a Royal battery
  discovery 2.{A}#."
```

### Cross-check by capture
**Enum**: `NamedTheme::CaptureCrossCheck`

Black checking defense is met by a White battery mate that captures a Black piece other than the checking piece.

```thema
def [a:+]
key [A:x:!@a]
where A.fires_battery
subsumes BatteryMate, BatteryPlay, CrossCheck,
  ProvokedCheck
story "Cross-check by capture:
  After Key 1.{K}!{threat_clause}, Black check 1...{a}
  is met by battery capture 2.{A}# (without capturing
  the checking unit)."
```

### Changed battery mates
**Enum**: `NamedTheme::ChangedBatteryMates`

Two Black defenses answered by battery checkmates in virtual play receive changed battery checkmates in actual play.

```thema
^vir [A B]
^key [C D]
where (A, B, C, D).fires_battery
subsumes BatteryMate, BatteryPlay
story "Changed battery mates: Battery mates against
  1...{a} and 1...{b} change from 2.{A}# and
  2.{B}# in {phase1} to 2.{C}# and 2.{D}# after
  Key 1.{K}!{threat_clause}."
```

### Pawn battery mate
**Enum**: `NamedTheme::PawnBatteryMate`

A White Pawn acts as the front piece of a battery, delivering discovered checkmate.

```thema
key [A:P]
where A.fires_battery
subsumes BatteryMate, BatteryPlay
story "Pawn battery mate: After Key 1.{K}!{threat_clause},
  White's Pawn fires a battery discovery with 2.{A}#
  after 1...{a}."
```

### Promotion battery mate
**Enum**: `NamedTheme::PromotionBatteryMate`

A White Pawn promotes while simultaneously firing a battery to deliver discovered checkmate.

```thema
key [A:P:=]
where A.fires_battery
subsumes PawnBatteryMate, PromotionKey
story "Promotion battery mate: After
  Key 1.{K}!{threat_clause}, White's Pawn promotes while
  firing a battery discovery with 2.{A}# after 1...{a}."
```

### Switchback battery mate
**Enum**: `NamedTheme::SwitchbackBatteryMate`

The White key piece returns to its departure square on move 2 while simultaneously firing a battery to deliver discovered checkmate.

```thema
key K [A~K]
where A.fires_battery
subsumes BatteryMate, BatteryPlay, Switchback
story "Switchback battery mate: Key 1.{K}!{threat_clause}
  returns to {K.from} to fire a battery discovery with
  2.{A}# after 1...{a}."
```

### Theme A
**Enum**: `NamedTheme::ThemeA` · *Alias*: Thema A

Two Black defenses arriving on the same square close two different Black lines, separating a White battery/slider dual so each defense allows only one of two mates.

```thema
key [A B]
where same_square(a, b), a.from != b.from,
  a.closes_line(), b.closes_line(),
  ((A.fires_battery && B.fires_battery)
    || (same_piece(A, B) && A.slider))
subsumes DefencesOnSameSquare
story "Theme A: Key 1.{K}!{threat_clause}.
  Two Black defenses on {a.to} (1...{a} and 1...{b}) close
  distinct lines to separate 2.{A}# and 2.{B}#."
```

### Anti-Roels
**Enum**: `NamedTheme::AntiRoels`

Tries threaten Royal battery mates refuted by Black slider defenses; the key changes the threat and answers those sliders with distinct mates.

```thema
try (X:K) [! _]
key (Y) [A B]
where X.fires_battery, a.slider, b.slider
with -match_threat_count
subsumes KingsBattery
story "Anti-Roels: Try 1.{Tr}? threatens Royal
  battery mate 2.{X}# (refuted by 1...{a}!);
  Key 1.{K}!{threat_clause} answers 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Foschini
**Enum**: `NamedTheme::Foschini` · *Alias*: Foschini theme

Two Black King flights step onto the lines of two different rear line-pieces sharing the same front battery piece, which fires discovered checkmates from each rear piece.

```thema
def [a:K b:K]
key [A B]
where a.to < b.to, same_piece(A, B), A.fires_battery,
  B.fires_battery, A.battery_rear != B.battery_rear
subsumes BatteryMate, BatteryPlay, KingFlight
story "Foschini: Key 1.{K}!{threat_clause}. Black King
  flights 1...{a} and 1...{b} step onto two battery
  lines sharing the front {A.role_name} on {A.from},
  which fires 2.{A}# and 2.{B}#."
```

### Szöghy 2
**Enum**: `NamedTheme::Szoghy2`

The key creates a half-battery, and at least two checking moves by the Black Queen/slider are answered by the front piece delivering discovered/double-check mates.

```thema
def [a:Q|R|B:+ b:Q|R|B:+]
key K [A B]
where same_piece(a, b), a.to != b.to, same_piece(A, B),
  A.to != B.to, A.fires_battery, B.fires_battery
subsumes BatteryMate, BatteryPlay, CrossCheck,
  ProvokedCheck
story "Szöghy 2: Key 1.{K}!{threat_clause} sets up
  battery cross-checks against Black {a.role} checks:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Führer theme
**Enum**: `NamedTheme::Fuehrer` · *Alias*: Fuehrer theme

Random and correction moves of a Black slider along a line allow the same White front battery piece to deliver three distinct discovered mates along a line.

```thema
def [a:B|R|Q b:B|R|Q c:B|R|Q]
key [A B C]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  same_piece(A, B, C), distinct(A.to, B.to, C.to),
  A.fires_battery, B.fires_battery, C.fires_battery
subsumes BatteryMate, BatteryPlay, Duel
story "Führer theme: Key 1.{K}!{threat_clause}. Black
  {a.role} moves 1...{a}, 1...{b}, 1...{c} are answered by
  battery piece {A.role} on {A.to}, {B.to}, and {C.to}."
```

### Mlynka
**Enum**: `NamedTheme::Mlynka` · *Alias*: Mlynka theme

Two tries with different threats share the same Royal battery variations against three Black defenses; the key changes those variations.

```thema
try (X) [A B:K !]
try (Y) [A B:K _]
key [C D E]
where B.fires_battery
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay, RoyalBattery
story "Mlynka: Tries 1.{Tr1}? (threat 2.{X}#) and 1.{Tr2}?
  (threat 2.{Y}#) share Royal battery mates 2.{A}# and
  2.{B}#, changed by Key 1.{K}!."
```

### Oudot theme
**Enum**: `NamedTheme::Oudot` · *Alias*: Oudot

A sacrificial key by a half-battery Knight creates a masked battery and provokes a Black checking capture answered by cross-check or double-check mate.

```thema
def [a:x:+ b:x@K]
key K:N [A B]
where (A.fires_battery || B.fires_battery
    || A.double_check)
subsumes BatteryMate, BatteryPlay, KnightSacrifice,
  ProvokedCheck
story "Oudot theme: Knight sacrifice
  Key 1.{K}!{threat_clause} creates a masked battery,
  answering checking capture 1...{a} with 2.{A}# and
  capture 1...{b} with 2.{B}#."
```

### Blikeng theme
**Enum**: `NamedTheme::Blikeng` · *Alias*: Blikeng

The White King is the front piece of a Royal battery and moves on the key to a new square while preserving the Royal battery, then fires Royal battery mates in the variations.

```thema
key K:K [A:K B:K]
where A.fires_battery, B.fires_battery, A.to != B.to
subsumes RoyalBattery
story "Blikeng theme: White King Key 1.{K}!{threat_clause}
  shifts the Royal battery and fires Royal battery mates
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Küchler theme
**Enum**: `NamedTheme::Kuchler` · *Alias*: Kuchler theme

The key abandons an existing White battery while granting a capture flight to the Black King and clearing a square for the key piece's recapture.

```thema
def [a:x b:K:x]
key K [A B]
where A.from == K.to,
  (between(K.battery_front, K.from, BK)
    || between(K.from, K.battery_rear, BK)
    || K.flights_given >= 1)
subsumes FlightCapture
story "Küchler theme: Key 1.{K}!{threat_clause} abandons
  a battery and grants capture flight 1...{b} (2.{B}#)
  while answering 1...{a} with 2.{A}#."
```

### Fleck-Burkhardt
**Enum**: `NamedTheme::FleckBurkhardt` · *Alias*: Windmill theme

The key threatens at least three discovered mates by the same front battery piece, and Black defenses separate them into individual mates.

```thema
key (ABC) [A B C]
where same_piece(A, B, C), distinct(A.to, B.to, C.to),
  (A.fires_battery || B.fires_battery || C.fires_battery)
with -match_threat_count
subsumes BatteryMate, BatteryPlay, DoubleThreat, Fleck
story "Fleck-Burkhardt (Windmill): Key 1.{K}! threatens
  multiple battery discoveries (2.{A}#, 2.{B}#, 2.{C}#),
  separated by 1...{a}, 1...{b}, and 1...{c}."
```

### Barthelemy
**Enum**: `NamedTheme::Barthelemy` · *Alias*: Barthelemy theme

Four moves by the same Black slider along its lines self-block or close lines, forcing two pairs of White battery/slider mates.

```thema
def [a:B|R|Q b:B|R|Q c:B|R|Q d:B|R|Q]
key [A B C D]
where same_piece(a, b, c, d),
  distinct(a.to, b.to, c.to, d.to), same_piece(A, B),
  same_piece(C, D), A.from != C.from
story "Barthelemy: Key 1.{K}!{threat_clause}. Four
  moves of Black's {a.role} (1...{a}, 1...{b}, 1...{c},
  1...{d}) force 2.{A}#, 2.{B}#, 2.{C}#, and 2.{D}#."
```

### Tema Argentino
**Enum**: `NamedTheme::TemaArgentino`

A White King key creates a half-battery and exposes the White King to a check, while three Black pieces (including the Black King) defend on the same square.

```thema
def [a:R|B|Q b:K c:Q|R|B]
key K:K [A B C]
where same_square(a, b, c),
  distinct(a.from, b.from, c.from)
subsumes ArrivalCorrection, KingFlight
story "Tema Argentino: White King
  Key 1.{K}!{threat_clause} induces three Black pieces
  (including the Black King) to defend on {a.to}:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Octagon theme
**Enum**: `NamedTheme::Octagon`

A single White Knight delivers discovered battery checkmates on at least five distinct squares of its octagon wheel against moves of a Black slider.

```thema
def [a:Q|R|B b:Q|R|B c:Q|R|B d:Q|R|B e:Q|R|B]
key [A:N B:N C:N D:N E:N]
where same_piece(a, b, c, d, e),
  same_piece(A, B, C, D, E),
  distinct(A.to, B.to, C.to, D.to, E.to), A.fires_battery
subsumes BatteryMate, BatteryPlay, Duel, WhiteKnightWheel
story "Octagon theme: Key 1.{K}!{threat_clause}. White's
  Knight on {A.from} fires battery mates on five octagon
  squares: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#, and 2.{E}#."
```

### Durbar
**Enum**: `NamedTheme::Durbar` · *Alias*: Durbar task

The White King makes the key move and then delivers at least four distinct Royal battery checkmates in the variations.

```thema
key K:K [A:K B:K C:K D:K]
where same_piece(A, B, C, D),
  distinct(A.to, B.to, C.to, D.to), A.fires_battery
subsumes Blikeng
story "Durbar: White King Key 1.{K}!{threat_clause} is
  followed by four Royal battery mates by the White King:
  2.{A}#, 2.{B}#, 2.{C}#, and 2.{D}#."
```

### Torngren theme
**Enum**: `NamedTheme::Torngren` · *Alias*: Torngren

A White pawn promotion key creates a battery or half-battery with a double threat on the same square.

```thema
key K:P:= (XY) [A B]
where X.to == Y.to, X.from != Y.from
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes KarlstromFleck, PromotionKey
story "Torngren theme: Promotion Key 1.{K}! threatens
  double capture on {X.to} (2.{X}#, 2.{Y}#), separated
  by 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Ekström theme
**Enum**: `NamedTheme::Ekstrom` · *Alias*: Ekstroem theme

The key creates a battery, and four Black pieces (two Knights and two sliders) move without capturing to the same square, forcing four distinct checkmates.

```thema
def [a:N:!x b:N:!x c:B|R|Q:!x d:B|R|Q:!x]
key K [A B C D]
where same_square(a, b, c, d),
  distinct(a.from, b.from, c.from, d.from),
  (A.fires_battery || B.fires_battery || C.fires_battery
    || D.fires_battery)
subsumes CederInterference, SelfInterference, Stocchi
story "Ekström theme: Key 1.{K}!{threat_clause}.
  Two Black Knights (1...{a}, 1...{b}) and two sliders
  (1...{c}, 1...{d}) converge on {a.to}, forcing 2.{A}#,
  2.{B}#, 2.{C}#, and 2.{D}#."
```

### Volga
**Enum**: `NamedTheme::Volga` · *Alias*: Volga theme

A key creates a masked battery and provokes two checking captures/moves by the same Black Rook, both answered by the key piece capturing the Rook to fire the battery.

```thema
def [a:R:+ b:R:+]
key K [A:x@a B:x@b]
where same_piece(a, b), a.to != b.to, A.from == K.to,
  B.from == K.to, A.fires_battery, B.fires_battery
subsumes BatteryMate, BatteryPlay, CrossCheck, Dentist
story "Volga: Key 1.{K}!{threat_clause} creates
  a masked battery and answers Rook checks 1...{a} and
  1...{b} by capturing the Rook with the key piece:
  2.{A}# and 2.{B}#."
```

---

## 04. Cyclic Systems & Grandmaster Complex Cycles

*Modern cyclic systems exchanging threats, defenses, refutations, and mates (Dombrovskis, Hannelius, Le Grand, Shedey, Vladimirov, Rudenko).*

### Banny
**Enum**: `NamedTheme::Banny`

Tries A and B are refuted by defenses b and a; in a subsequent phase, defenses a and b are answered by the respective try moves A and B.

```thema
try A [_ !]
try B [! _]
+any  [A B]
with -no_threats_few_replies -no_threats_sparse_mates
  -capture_try_piece -refutation_is_check
  -match_threat_count -match_mate_count -single_refutation
story "Banny: Tries 1.{A}? (refuted by 1...{b}!) and
  1.{B}? (refuted by 1...{a}!) are answered reciprocally
  in subsequent play: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
try A [! _]
try B [_ !]
+any  [B A]
story "Banny: Tries 1.{A}? (refuted by 1...{a}!) and
  1.{B}? (refuted by 1...{b}!) are answered reciprocally
  in subsequent play: 1...{a} 2.{B}# and 1...{b} 2.{A}#."
---
vir   [A B]
try A [_ !]
try B [! _]
with -no_threats_few_replies -no_threats_sparse_mates
  -capture_try_piece -refutation_is_check
  -match_threat_count -match_mate_count -single_refutation
story "Banny: Virtual mates 1...{a} 2.{A}# and
  1...{b} 2.{B}# reappear as tries 1.{A}? (refuted
  by 1...{b}!) and 1.{B}? (refuted by 1...{a}!)."
```

### Cyclic Banny
**Enum**: `NamedTheme::CyclicBanny`

Cyclic Banny across 3 phases: Try 1 (move A) refuted by a; Try 2 (move B) refuted by b; Try 3 (move C) refuted by c; Key answers defenses with B, C, A.

```thema
try A [! _ _]
try B [_ ! _]
try C [_ _ !]
key   [B C A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Banny
story "Cyclic Banny: Tries 1.{A}?, 1.{B}?, and 1.{C}? are
  answered cyclically after key 1.{K}!{threat_clause}:
  1...{a} 2.{B}#, 1...{b} 2.{C}#, 1...{c} 2.{A}#."
```

### Hannelius
**Enum**: `NamedTheme::Hannelius` · *Alias*: Set Hannelius

Reciprocal changed threat theme: Try 1 threatens X (refuted by a); Try 2 threatens Y (refuted by b); Key answers defense a with Y, and defense b with X.

```thema
try (X) [! _]
try (Y) [_ !]
+any    [Y X]
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
  -refutation_is_check
story "Hannelius: Tries 1.{Tr1}? (threat 2.{X}#, refuted
  by 1...{a}!) and 1.{Tr2}? (threat 2.{Y}#, refuted
  by 1...{b}!) have their threats reciprocally transferred
  to defenses in the key 1.{K}!{threat_clause}:
  1...{a} 2.{Y}# and 1...{b} 2.{X}#."
---
vir     [Y X]
try (X) [! _]
try (Y) [_ !]
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
  -refutation_is_check
story "Hannelius: Virtual mates 1...{a} 2.{Y}# and
  1...{b} 2.{X}# reappear reciprocally as threats in tries
  1.{Tr1}? (threat 2.{X}#, refuted by 1...{a}!) and
  1.{Tr2}? (threat 2.{Y}#, refuted by 1...{b}!)."
```

### Cyclic Hannelius
**Enum**: `NamedTheme::CyclicHannelius`

Cyclic changed threat theme across 3 phases: tries threaten X, Y, Z (refuted by a, b, c); Key answers a, b, c cyclically with Y, Z, X.

```thema
try (X) [! _ _]
try (Y) [_ ! _]
try (Z) [_ _ !]
key     [Y Z X]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Dad, Hannelius
story "Cyclic Hannelius: Three try threats 2.{X}#,
  2.{Y}#, 2.{Z}# are cyclically permuted in the key
  1.{K}!{threat_clause}: 1...{a} 2.{Y}#, 1...{b} 2.{Z}#,
  1...{c} 2.{X}#."
```

### Dombrovskis
**Enum**: `NamedTheme::Dombrovskis` · *Alias*: Set Dombrovskis

Tries threaten A and B, refuted by defenses a and b; Key answers defense a with A, and defense b with B.

```thema
try (A) [! _]
try (B) [_ !]
+any    [A B]
with -match_mate_count -single_refutation
  -capture_try_piece
story "Dombrovskis: Try threats 2.{A}# (from 1.{Tr1}?,
  refuted by 1...{a}!) and 2.{B}# (from 1.{Tr2}?,
  refuted by 1...{b}!) return as post-key mates
  after 1.{K}!{threat_clause}: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
---
try (A) [! _]
+any (B) [A]
with -match_mate_count -capture_try_piece
story "Dombrovskis: Try threat 2.{A}# (from 1.{Tr}?,
  refuted by 1...{a}!) returns as post-key mate after
  1.{K}! (threat 2.{B}#): 1...{a} 2.{A}#."
---
try A (B) [! !]
+any [A B]
with -match_mate_count -capture_try_piece
story "Dombrovskis: Try 1.{A}? (threat 2.{B}#) is refuted
  by 1...{a}! and 1...{b}!, which are answered by 2.{A}#
  and 2.{B}# after Key 1.{K}!{threat_clause}."
---
vir     [A B]
try (A) [! _]
try (B) [_ !]
with -match_mate_count -single_refutation
  -capture_try_piece
story "Dombrovskis: Virtual mates 1...{a} 2.{A}# and
  1...{b} 2.{B}# reappear as try threats in 1.{Tr1}?
  (threat 2.{A}#, refuted by 1...{a}!) and 1.{Tr2}?
  (threat 2.{B}#, refuted by 1...{b}!)."
---
try (A) [! _ _ _]
try (B) [_ ! _ _]
+any    [_ _ A B]
with -match_mate_count -single_refutation
  -capture_try_piece
story "Dombrovskis: Try threats 2.{A}# and 2.{B}# return
  as defensive mates after Key 1.{K}!{threat_clause}:
  1...{c} 2.{A}# and 1...{d} 2.{B}#."
```

### Dombrovskis Paradox
**Enum**: `NamedTheme::DombrovskisParadox`

A try threatens X and is refuted by defense a; in the solution, defense a is answered by checkmate with X.

```thema
try (X) [!]
key     [X]
story "Dombrovskis paradox: Try threat 2.{X}# (from
  1.{Tr}?, refuted by 1...{a}!) returns as checkmate after
  key 1.{K}!{threat_clause}: 1...{a} 2.{X}#."
```

### Ideal Dombrovskis
**Enum**: `NamedTheme::DombrovskisIdeal`

Try 1 threatens X, refuted by a (mates b with A); Try 2 threatens Y, refuted by b (mates a with B); Key mates a with X and b with Y.

```thema
try (X) [! A]
try (Y) [B !]
key     [X Y]
subsumes DefBasedHannelius, Dombrovskis, Dombrovsky,
  Makrava
story "Ideal Dombrovskis: Try threats 2.{X}# (1.{Tr1}?)
  and 2.{Y}# (1.{Tr2}?) reappear as actual mates against
  the refutations after key 1.{K}!{threat_clause}:
  1...{a} 2.{X}# and 1...{b} 2.{Y}#."
```

### Dombrovskis Cross-Closed 1
**Enum**: `NamedTheme::DombrovskisCrossClosed1`

Dombrovskis cross-closed 1: Try 1 threatens A (refuted by a, mates B against b); Try 2 threatens B (mates A against a, refuted by b); solved by Key K.

```thema
try (A) [! B]
try (B) [A !]
key K
subsumes Dombrovskis, Dombrovsky, PseudoLeGrand,
  TransferredMates
story "Dombrovskis Cross-Closed 1:
  Try 1.{Tr1}? (threat 2.{A}#, refuted by 1...{a}!,
  allows 1...{b} 2.{B}#) and Try 1.{Tr2}? (threat 2.{B}#,
  allows 1...{a} 2.{A}#, refuted by 1...{b}!) cross-close,
  resolved by key 1.{K}!{threat_clause}."
```

### Vladimirov
**Enum**: `NamedTheme::Vladimirov`

A White try move X is refuted by defense a; in the Key, defense a is answered by mate move X.

```thema
try X [!]
any   [X]
with -capture_try_piece -match_threat_count
story "Vladimirov: White try move 1.{X}? (refuted
  by 1...{a}!) returns as checkmate after key
  1.{K}!{threat_clause}: 1...{a} 2.{X}#."
---
try A (B) [! !]
key [A B]
with -capture_try_piece -match_threat_count
story "Vladimirov: White try move 1.{A}? and threat
  2.{B}# (refuted by 1...{a}! and 1...{b}!) return
  as checkmates after key 1.{K}!{threat_clause}:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Vladimirov Cross-Closed 1
**Enum**: `NamedTheme::VladimirovCC1`

Vladimirov cross-closed: Try A refuted by defense a (mates b with B); Try B answers defense a with A, refuted by b.

```thema
try A [! B]
try B [A !]
key K
with -capture_try_piece -match_threat_count
  -no_threats_sparse_mates -no_threats_few_replies
  -single_refutation -refutation_is_check
subsumes ChangedPlay, PseudoSalazar, Vladimirov
story "Vladimirov Cross-Closed 1: Try moves 1.{A}?
  (refuted by 1...{a}!) and 1.{B}? (refuted by 1...{b}!)
  cross-answer the refutations as checkmates, resolved
  by key 1.{K}!{threat_clause}."
```

### Le Grand
**Enum**: `NamedTheme::Legrand`

Try threatens A, with defense a answered by B; Key threatens B, with defense a answered by A.

```thema
try (A) [B]
+any (B) [A]
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
  -refutation_is_check
subsumes ChangedMate
story "Le Grand: Try 1.{Tr}? threatens 2.{A}# (answered
  by 1...{a} 2.{B}#); Key 1.{K}! mirrors the play,
  threatening 2.{B}# with 1...{a} 2.{A}# against
  the defense."
```

### Pseudo-Le Grand
**Enum**: `NamedTheme::PseudoLeGrand`

Phase 1 threatens A (defense a answered by B); Phase 2 threatens B (defense b answered by A).

```thema
vir (A) [B _]
+any (B) [_ A]
with -refutation_is_check -capture_try_piece
  -match_threat_count -match_mate_count -single_refutation
subsumes ChangedMate
story "Pseudo-Le Grand: Try 1.{Tr}? threatens 2.{A}#
  (answered by 1...{a} 2.{B}#); Key 1.{K}! threatens
  2.{B}# (answered by 1...{b} 2.{A}#), producing
  a reciprocal threat-mate transference."
```

### Cyclic Le Grand
**Enum**: `NamedTheme::CyclicLeGrand`

Cyclic permutation of threats and mates against defense a across 3 phases: Try 1 threatens A (mates B); Try 2 threatens B (mates C); Key threatens C (mates A).

```thema
try (A) [B]
try (B) [C]
key (C) [A]
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
  -refutation_is_check
subsumes ChangedPlay, PseudoCyclicLeGrand
story "Cyclic Le Grand: Three phases cyclically
  permute threats and defensive mates:
  Try 1.{Tr1}? (threat 2.{A}#, 1...{a} 2.{B}#),
  Try 1.{Tr2}? (threat 2.{B}#, 1...{a} 2.{C}#),
  and Key 1.{K}! (threat 2.{C}#, 1...{a} 2.{A}#)."
```

### Lacny
**Enum**: `NamedTheme::Lacny` · *Alias*: Lacny Cycle

Cyclic change of mates across two phases against defenses a, b, c (A, B, C to B, C, A).

```thema
vir [A B C]
key [B C A]
subsumes ThreeChangedMates, TransferredMates
story "Lacny cycle: Cyclically permuted checkmates
  across phases (A -> B -> C -> A) against defenses
  1...{a}, 1...{b}, and 1...{c}, completed by key
  1.{K}!{threat_clause}."
```

### Complete Lacny
**Enum**: `NamedTheme::LacnyComplete`

Complete cyclic change of mates across 3 phases against defenses a, b, c (A, B, C / B, C, A / C, A, B).

```thema
vir [A B C]
try [B C A]
key [C A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes AntiCarousel, CounterCarousel, RiceCycle,
  ZagoruikoCyclic
story "Complete Lacny: Flawless cyclic permutation
  of three defensive mates across three phases:
  {phase1} (2.{A}#, 2.{B}#, 2.{C}#), try 1.{Tr}? (2.{B}#,
  2.{C}#, 2.{A}#), and key 1.{K}!{threat_clause} (2.{C}#,
  2.{A}#, 2.{B}#)."
```

### Dombrovskis-Lacny
**Enum**: `NamedTheme::DombroLacny`

Combination of Dombrovskis and Lacny: Try threatens A (mates B, C against defenses a, b); Key threatens B (mates C, A against a, b).

```thema
try (A) [B C]
key (B) [C A]
subsumes Isaev, PseudoLeGrand, ThreatKey, TransferredMates
story "Dombrovskis-Lacny: Try 1.{Tr}? (threat 2.{A}#,
  defenses 1...{a} 2.{B}#, 1...{b} 2.{C}#) and Key 1.{K}!
  (threat 2.{B}#, defenses 1...{a} 2.{C}#, 1...{b} 2.{A}#)
  synthesize Dombrovskis threats and Lacny cyclic mates."
```

### Shedey Cycle
**Enum**: `NamedTheme::ShedeyCycle` · *Alias*: Shedey theme

Cyclic change between threats, phase moves, and defensive mates across three phases (e.g., mate A in tries becomes threat A in the Key).

```thema
try [A C]
try [D A]
key (A) [E F]
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
story "Shedey cycle: Key 1.{K}! threatens 2.{A}#
  (answering defenses with 2.{E}# and 2.{F}#), completing
  a cyclic permutation of threats and defensive mates
  across phases."
---
vir [A !A]
+try [!A A]
+key (A) [!A !A]
with -match_threat_count -match_mate_count
story "Shedey cycle: Mate 2.{A}# against 1...{a}
  in {phase1} transfers to 1...{b} in Try 1.{Tr}? and
  becomes the threat in {phase3}."
---
vir [A B]
try (A) [! _]
+any (B) [C D]
where A != C
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
  -refutation_is_check
story "Shedey cycle: Defensive mates 2.{A}# and 2.{B}#
  from {phase1} reappear as threats across Try 1.{Tr}?
  and {phase3}."
---
any A [B _]
+any (B) [A _]
+any [A B]
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
  -refutation_is_check
story "Shedey cycle: Moves 2.{A}# and 2.{B}# cycle
  through phase move, threat, and defensive mates across
  three phases."
```

### Complete Kiss
**Enum**: `NamedTheme::KissComplete`

Complete Kiss cycle across 3 phases: Try A (mates B, C), Try B (mates C, A), and Key C (mates A, B) against defenses a and b.

```thema
try A [B C]
try B [C A]
key C [A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes AntiReversal, Brabec3, ComplexBanny, Kiss,
  RiceCycle, ZagoruikoCyclic
story "Complete Kiss: Full thematic matrix
  of changed checkmates across tries 1.{A}?, 1.{B}?,
  and key 1.{C}!{threat_clause} against defenses 1...{a}
  and 1...{b}."
```

### Rudenko
**Enum**: `NamedTheme::Rudenko`

Tries threaten A and B (refuted by defenses a and b) and Key answers a and b reciprocally with B and A; or double threat AB in one phase separates into variation mates A and B in another phase.

```thema
try (A) [! _]
try (B) [_ !]
key [B A]
story "Rudenko: Tries 1.{Tr1}? (threat 2.{A}#,
  refuted by 1...{a}!) and 1.{Tr2}? (threat 2.{B}#,
  refuted by 1...{b}!) have their threats reciprocally
  answered after key 1.{K}!{threat_clause}:
  1...{a} 2.{B}# and 1...{b} 2.{A}#."
---
try (AB)
+any [A B]
with -capture_try_piece -refutation_is_check
  -single_refutation
story "Rudenko: Double threat 2.{AB}# in try 1.{Tr}?
  is separated into defensive variation mates:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
vir [A B]
+any (AB)
with -capture_try_piece -refutation_is_check
  -single_refutation
story "Rudenko: Variation mates 1...{a} 2.{A}# and 1...{b}
  2.{B}# in {phase1} become the double threat 2.{AB}#."
```

### Rudenko (Reversal Form)
**Enum**: `NamedTheme::RudenkoReversal`

Double threat AB with defensive mates C, D in try, answered by mates A, B in key.

```thema
try (AB) [C D]
key [A B]
subsumes ChangedPlay, DoubleThreat, Rudenko
story "Rudenko (Reversal Form): Try 1.{Tr}? carries
  double threat 2.{AB}# (answered by 1...{a} 2.{C}# and
  1...{b} 2.{D}#); Key 1.{K}!{threat_clause} converts
  the threats into defensive mates: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Rice Cycle
**Enum**: `NamedTheme::RiceCycle`

Cyclic permutation of mates across three phases against defenses a and b (A, B / B, C / C, A).

```thema
vir [A B]
try [B C]
key [C A]
with -no_threats_sparse_mates -no_threats_few_replies
  -refutation_is_check -capture_try_piece
  -single_refutation -match_threat_count -match_mate_count
subsumes ChangedPlay, TransferredMates
story "Rice cycle: Cyclic permutation of defensive
  mates across tries 1.{Tr1}?, 1.{Tr2}?, and key
  1.{K}!{threat_clause}: 1...{a} 2.{A}#, 2.{B}#, 2.{C}#."
```

### Jurasevic
**Enum**: `NamedTheme::Jurasevic` · *Alias*: Djurasevic

Cyclic relation between phase move, threat, and mate against defense a: Try A threatens B (mates C); Key B threatens C (mates A).

```thema
try A (B) [C]
key B (C) [A]
subsumes AntiReversal, Erokhin, ThreatAntiReversal
story "Djurasevic: Try 1.{A}? (threat 2.{B}#, defense
  1...{a} 2.{C}#) and key 1.{B}! (threat 2.{C}#, defense
  1...{a} 2.{A}#) exhibit cyclic permutation of key,
  threat, and mate (A -> B -> C -> A)."
---
try Tr (C) [!]
key K (A) [C]
where same_square(Tr, K), Tr.from != K.from
with -refutation_is_check -capture_try_piece
story "Djurasevic: Try 1.{Tr}? (threat 2.{C}#,
  refuted by 1...{a}!) and key 1.{K}! (threat 2.{A}#,
  1...{a} 2.{C}#) share destination {K.to} and transfer
  threat 2.{C}# into a variation mate."
```

### Cyclic Pseudo-Anti-Reversal
**Enum**: `NamedTheme::CyclicPseudoAntiReversal`

Cyclic pseudo anti-reversal across three phases: Try A (1...a 2.B#), Try B (1...b 2.C#), and Key C (1...c 2.A#).

```thema
try A [B _ _]
try B [_ C _]
key C [_ _ A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedMate
story "Cyclic pseudo-anti-reversal: Cyclic changed
  play across three phases (Try 1.{A}?, Try 1.{B}?, Key
  1.{C}!{threat_clause}) parrying reciprocal reversal."
```

### Pseudo-Cyclic Le Grand
**Enum**: `NamedTheme::PseudoCyclicLeGrand`

Cyclic permutation of threats and mates across three phases and three defenses: Try 1 threatens A (1...a 2.B#), Try 2 threatens B (1...b 2.C#), Key threatens C (1...c 2.A#).

```thema
try (A) [B _ _]
try (B) [_ C _]
key (C) [_ _ A]
subsumes ThreatKey, TransferredMates
story "Pseudo-Cyclic Le Grand: Cyclic transfer of threats
  and mates across Try 1.{Tr1}? (threat 2.{A}#),
  Try 1.{Tr2}? (threat 2.{B}#), and Key 1.{K}!
  (threat 2.{C}#)."
```

### Double Le Grand
**Enum**: `NamedTheme::LegrandDouble`

Double Le Grand: Try 1 threatens A (1...a 2.C#), Try 2 threatens B (1...b 2.C#), and Key threatens C (1...a 2.A#, 1...b 2.B#); or double threats AB and CD swap with mates C, D and A, B.

```thema
try (A) [C _]
try (B) [_ C]
key (C) [A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Legrand, ThreatKey
story "Double Le Grand: Two distinct pairs of threats and
  variations reciprocally exchanged across tries 1.{Tr1}?,
  1.{Tr2}?, and key 1.{K}! (threat 2.{C}#, 1...{a} 2.{A}#,
  1...{b} 2.{B}#)."
---
try (AB) [C D _]
key (CD) [A B _]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Legrand, ThreatKey
story "Double Le Grand: Double threats (2.{A}#, 2.{B}#)
  and variation mates (2.{C}#, 2.{D}#) reciprocally
  exchange between Try 1.{Tr}? and Key 1.{K}!."
```

### Double Le Grand Condensed
**Enum**: `NamedTheme::LegrandDoubleCondensed`

Condensed double Le Grand: Try 1 threatens AB (refuted by a), Try 2 threatens A (1...a 2.B#), and Key threatens B (1...a 2.A#).

```thema
try (AB) [!]
try (A) [B]
key (B) [A]
subsumes Barnes, DoubleThreat, Legrand, ThreatKey
story "Double Le Grand Condensed: Compact reciprocal
  transfer between threats and mates across tries
  1.{Tr1}?, 1.{Tr2}?, and key 1.{K}! (threat 2.{B}#,
  1...{a} 2.{A}#)."
```

### Dombrovskis Cross-Closed 2
**Enum**: `NamedTheme::DombrovskisCrossClosed2`

Try threatens A (answers defense a with C and defense b with B); Key threatens B (answers defense a with A and defense b with D).

```thema
try (A) [C B]
key (B) [A D]
subsumes ChangedPlay, Isaev, PseudoLeGrand, ThreatKey
story "Dombrovskis Cross-Closed 2: Dual cross-closed
  reciprocal relations between try 1.{Tr}? (threat 2.{A}#,
  1...{a} 2.{C}#, 1...{b} 2.{B}#) and key 1.{K}!
  (threat 2.{B}#, 1...{a} 2.{A}#, 1...{b} 2.{D}#)."
```

### Dombrovskis Defense-Based
**Enum**: `NamedTheme::DombrovskiDefenceBased`

Defense-based Dombrovskis: Try 1 threatens A (1...a 2.C#), Try 2 threatens B (1...b 2.D#), and Key answers defenses a and b with mates A and B.

```thema
try (A) [C -]
try (B) [- D]
key [A B]
subsumes ChangedMate, TransferredMates
story "Dombrovskis Defense-Based: Try threats
  2.{A}# (1.{Tr1}?) and 2.{B}# (1.{Tr2}?) return as
  defensive mates after key 1.{K}!{threat_clause}:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Ideal Hannelius
**Enum**: `NamedTheme::IdealHannelius`

Ideal Hannelius: Try 1 threatens A (refuted by a, 1...b 2.C#), Try 2 threatens B (1...a 2.D#, refuted by b), and Key answers defenses a and b with mates B and A.

```thema
try (A) [! C]
try (B) [D !]
key [B A]
subsumes DombrovskiDefenceBased, DombrovskisReciprocal,
  Makrava, Rudenko
story "Ideal Hannelius: Tries 1.{Tr1}? (threat 2.{A}#,
  refuted by 1...{a}!) and 1.{Tr2}? (threat 2.{B}#,
  refuted by 1...{b}!) have their threats reciprocated
  in the key 1.{K}!{threat_clause}: 1...{a} 2.{B}# and
  1...{b} 2.{A}#."
```

### Defense-Based Hannelius
**Enum**: `NamedTheme::DefBasedHannelius`

Defense-based Hannelius: Try 1 threatens A (1...a 2.C#), Try 2 threatens B (1...b 2.D#), and Key answers defenses a and b reciprocally with mates B and A.

```thema
try (A) [C _]
try (B) [_ D]
key [B A]
subsumes ChangedMate, TransferredMates
story "Defense-Based Hannelius: Reciprocated threat-mate
  transference across tries 1.{Tr1}?, 1.{Tr2}?,
  and key 1.{K}!{threat_clause}: 1...{a} 2.{B}# and
  1...{b} 2.{A}#."
```

### Zagoruiko Cyclic
**Enum**: `NamedTheme::ZagoruikoCyclic`

Cyclic change of mates across three phases against defenses a and b (A, B / B, C / C, A).

```thema
vir [A B]
try [B C]
key [C A]
subsumes ChangedPlay, TransferredMates
story "Zagoruiko Cyclic: Cyclic permutation of changed
  mates across three phases (tries 1.{Tr1}?, 1.{Tr2}?,
  and key 1.{K}!{threat_clause}) against defenses 1...{a}
  and 1...{b}."
```

### Lacny 2x4
**Enum**: `NamedTheme::Lacny2x4`

Cyclic shift of mates across four Black defenses a, b, c, d between two phases (A, B, C, D to B, C, D, A).

```thema
vir [A B C D]
key [B C D A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes FourChangedMates, Rukhlis, RukhlisCondensed
story "Lacny 2×4: Cyclic permutation of four checkmates
  across {phase1} and key 1.{K}!{threat_clause}:
  A -> B -> C -> D -> A against defenses 1...{a}, 1...{b},
  1...{c}, and 1...{d}."
```

### Dombrovskis-Lacny Complete
**Enum**: `NamedTheme::DombroLacnyComplete`

Complete 3-phase Dombrovskis-Lacny cycle: Try 1 threatens A (mates B, C), Try 2 threatens B (mates C, A), Key threatens C (mates A, B) against defenses a and b.

```thema
try (A) [B C]
try (B) [C A]
key (C) [A B]
subsumes Brabec3, CyclicLeGrand, DombroLacny, RiceCycle,
  ShedeyCycle, TwinThreatChange, Ukrainian,
  ZagoruikoCyclic
story "Dombrovskis-Lacny Complete: Full cyclic synthesis
  of Dombrovskis threats and Lacny mates across tries
  1.{Tr1}?, 1.{Tr2}?, and key 1.{K}! (threat 2.{C}#,
  defenses 1...{a} 2.{A}#, 1...{b} 2.{B}#)."
```

### Vladimirov Cross-Closed 2
**Enum**: `NamedTheme::VladimirovCC2`

Vladimirov cross-closed 2: Try A answers defense a with C and defense b with B; Key B answers defense a with A and defense b with D (or Try A mates B and Key B mates A).

```thema
try A [C B]
key B [A D]
story "Vladimirov Cross-Closed 2: Try 1.{A}? (1...{a}
  2.{C}#, 1...{b} 2.{B}#) and Key 1.{B}! (1...{a} 2.{A}#,
  1...{b} 2.{D}#) cross-answer the refutations."
---
try A [B]
key B [A]
subsumes ChangedMate
story "Vladimirov Cross-Closed 2: Try 1.{A}? (1...{a}
  2.{B}#) and Key 1.{B}! (1...{a} 2.{A}#) reciprocally
  exchange first and second moves."
```

### Vladimirov Ideal
**Enum**: `NamedTheme::VladimirovIdeal`

Ideal Vladimirov: Try A (refuted by a, 1...b 2.C#) and Try B (1...a 2.D#, refuted by b) reappear as variation mates A and B against defenses a and b in the Key.

```thema
try A [! C]
try B [D !]
key [A B]
subsumes ChangedMate, ReciprocalBanny
story "Vladimirov Ideal: White try moves 1.{A}?
  and 1.{B}? reappear as checkmates in the solution
  after key 1.{K}!{threat_clause}: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Carousel
**Enum**: `NamedTheme::Carousel`

Cyclic permutation of mates across three defenses a, b, c (e.g., Try answers a, b, c with A, B, C; Key answers a, b, c with B, C, A).

```thema
try [A B C]
key [B C A]
with -single_refutation -capture_try_piece -sparse_mates
  -few_replies -refutation_is_check -match_threat_count
story "Carousel: Cyclic carousel of checkmates across try
  1.{Tr}? and key 1.{K}!{threat_clause}: 1...{a} 2.{B}#,
  1...{b} 2.{C}#, 1...{c} 2.{A}#."
---
try [A B !]
try [! C A]
with -single_refutation -capture_try_piece -sparse_mates
  -few_replies -refutation_is_check -match_threat_count
story "Carousel: Cyclic shift of mates and refutations
  across tries 1.{Tr1}? and 1.{Tr2}? against defenses
  1...{a}, 1...{b}, and 1...{c}."
---
vir [A B _]
try [C _ B]
key [_ C A]
with -single_refutation -capture_try_piece -sparse_mates
  -few_replies -refutation_is_check -match_threat_count
subsumes ChangedMate
story "Carousel: Cyclic carousel of checkmates 2.{A}#,
  2.{B}#, and 2.{C}# across three phases against defenses
  1...{a}, 1...{b}, and 1...{c}."
---
vir [A B C]
try [C A !]
key (B) [- C A]
with -single_refutation -capture_try_piece -sparse_mates
  -few_replies -refutation_is_check -match_threat_count
subsumes ChangedMate
story "Carousel: Cyclic carousel of checkmates 2.{A}#,
  2.{B}#, and 2.{C}# across three phases against defenses
  1...{a}, 1...{b}, and 1...{c}."
```

### Counter-Carousel
**Enum**: `NamedTheme::CounterCarousel`

Counter-cyclic permutation of mates across three defenses a, b, c: Try answers a, b, c with A, B, C; Key answers a, b, c with C, A, B.

```thema
try [A B C]
key [C A B]
subsumes Carousel, Lacny, RukhlisCondensed
story "Counter-Carousel: Counter-cyclic carousel
  of checkmates across try 1.{Tr}? and key
  1.{K}!{threat_clause}: 1...{a} 2.{C}#, 1...{b} 2.{A}#,
  1...{c} 2.{B}#."
```

### Anti-Carousel
**Enum**: `NamedTheme::AntiCarousel`

Anti-carousel counter-cyclic permutation of mates A, B, C across defenses a, b, c (Try: A, B, C; Key: C, A, B).

```thema
try [A B C]
key [C A B]
subsumes Lacny, RukhlisCondensed
story "Anti-Carousel: Counter-cyclic permutation
  of checkmates across try 1.{Tr}? and key
  1.{K}!{threat_clause} against defenses 1...{a}, 1...{b},
  and 1...{c}."
---
vir [A B _]
try [C _ B]
key [_ C A]
with -single_refutation -capture_try_piece -sparse_mates
  -few_replies
story "Anti-Carousel: Cyclic permutation of checkmates
  2.{A}#, 2.{B}#, and 2.{C}# across three phases against
  defenses 1...{a}, 1...{b}, and 1...{c}."
```

### Complex Banny
**Enum**: `NamedTheme::ComplexBanny`

Tries 1.A? and 1.B? feature a common variation mate X against two defenses, which the key answers reciprocally with 2.B# and 2.A#.

```thema
try A [X _]
try B [_ X]
key [B A]
subsumes ChangedMate
story "Complex Banny: Tries 1.{A}? and 1.{B}? feature
  common mate 2.{X}#; Key 1.{K}!{threat_clause} answers
  defenses 1...{a} with 2.{B}# and 1...{b} with 2.{A}#."
```

### Banny Ideal
**Enum**: `NamedTheme::BannyIdeal`

Ideal Banny: Try A (refuted by a, 1...b 2.C#) and Try B (1...a 2.D#, refuted by b) are answered reciprocally in the Key with 1...a 2.B# and 1...b 2.A#.

```thema
try A [! C]
try B [D !]
key [B A]
subsumes BannyInverted, ChangedMate
story "Banny Ideal: Tries 1.{A}? (refuted by 1...{a}!,
  allows 1...{b} 2.{C}#) and 1.{B}? (allows
  1...{a} 2.{D}#, refuted by 1...{b}!) are answered
  reciprocally after key 1.{K}!{threat_clause}:
  1...{a} 2.{B}# and 1...{b} 2.{A}#."
```

### Banny Inverted
**Enum**: `NamedTheme::BannyInverted`

Inverted Banny: Try A (refuted by defense a) and Try B (refuted by defense b) are answered reciprocally in a subsequent phase with 1...a 2.B# and 1...b 2.A#.

```thema
try A [! _]
try B [_ !]
+any [B A]
story "Banny Inverted: Tries 1.{A}? (refuted
  by 1...{a}!) and 1.{B}? (refuted by 1...{b}!) have
  inverted reciprocal replies in subsequent play:
  1...{a} 2.{B}# and 1...{b} 2.{A}#."
```

### Banny Inverted Cyclic
**Enum**: `NamedTheme::BannyInvertedCyclic`

Cyclic inverted Banny: Tries A, B, C (refuted by defenses a, b, c) are answered cyclically in the Key with mates B, C, A.

```thema
try A [! _ _]
try B [_ ! _]
try C [_ _ !]
key [B C A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "Banny Inverted Cyclic: Three tries 1.{A}?,
  1.{B}?, 1.{C}? with individual refutations are
  answered cyclically after key 1.{K}!{threat_clause}:
  1...{a} 2.{B}#, 1...{b} 2.{C}#, 1...{c} 2.{A}#."
```

### Rukhlis Cyclic
**Enum**: `NamedTheme::RukhlisCyclic`

Cyclic Rukhlis transference across three phases and three defenses a, b, c: virtual play (A, B, _), Try (_, A, B), and Key (B, _, A).

```thema
vir [A B]
try [_ A B]
key [B _ A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Brabec3, Rukhlis
story "Rukhlis Cyclic: Cyclic transference of mating
  replies across {phase1}, try 1.{Tr}?, and key
  1.{K}!{threat_clause}."
```

### Mäkihovi-Robert Cyclic
**Enum**: `NamedTheme::MakihoviRobertCyclic`

Cyclic Mäkihovi-Robert synthesis against defense a: Try 1 has triple mate ABC, Try 2 threatens A (mates B), Try 3 threatens B (mates C), Key threatens C (mates A).

```thema
try [ABC]
try (A) [B]
try (B) [C]
key (C) [A]
subsumes CyclicLeGrand, MakihoviRobert, Ukrainian
story "Mäkihovi-Robert Cyclic: Cyclic synthesis
  of Mäkihovi separation and Robert changed play across
  tries 1.{Tr1}?, 1.{Tr2}?, 1.{Tr3}?, and key 1.{K}!
  (threat 2.{C}#, defense 1...{a} 2.{A}#)."
```

### Cycle of Double Threats
**Enum**: `NamedTheme::CycleDoubleThreats`

Cyclic double threats across three phases: AB -> BC -> CA.

```thema
try (AB)
try (BC)
+any (CA)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes DoubleThreat
story "Cycle of Double Threats: Three phases cyclically
  permute double threats: Try 1.{Tr1}? (2.{AB}#),
  Try 1.{Tr2}? (2.{BC}#), and 1.{K} (2.{CA}#)."
```

### Cycle of Multiple Threats
**Enum**: `NamedTheme::CycleMultipleThreats`

Cyclic multiple threats across three phases: ABC -> BCD -> CDA.

```thema
try (ABC)
try (BCD)
+any (CDA)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes DoubleThreat
story "Cycle of Multiple Threats: Three phases cyclically
  permute triple threats: Try 1.{Tr1}? (2.{ABC}#),
  Try 1.{Tr2}? (2.{BCD}#), and 1.{K} (2.{CDA}#)."
```

### Odessa Cyclic
**Enum**: `NamedTheme::OdessaCyclic`

Cyclic Odessa across three phases: Try 1 threatens AB (mates C, D on a, b), Try 2 threatens CD (mates E, F on c, d), Key threatens EF (mates A, B on c, d).

```thema
try (AB) [C D _ _]
try (CD) [_ _ E F]
key (EF) [_ _ A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay, KarlstromFleck, Rudenko
story "Odessa Cyclic: Cyclic transfer of threats
  to defensive mates across tries 1.{Tr1}?, 1.{Tr2}?,
  and key 1.{K}! (threat 2.{EF}#, 1...{c} 2.{A}#,
  1...{d} 2.{B}#)."
---
try (AB) [C D _ _ _ _]
try (CD) [_ _ E F _ _]
key (EF) [_ _ _ _ A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay, KarlstromFleck, Rudenko
story "Odessa Cyclic: Cyclic transfer of threats
  to defensive mates across tries 1.{Tr1}?, 1.{Tr2}?,
  and key 1.{K}! (threat 2.{EF}#, 1...{e} 2.{A}#,
  1...{f} 2.{B}#)."
```

### Mai 2 Cyclic
**Enum**: `NamedTheme::Mai2Cyclic`

Cyclic Mai 2 across three phases: Try 1 threatens AB (dual mate CD on a), Try 2 threatens CD (dual mate EF on b), Key threatens EF (dual mate AB on b).

```thema
try (AB) [CD _]
try (CD) [_ EF]
key (EF) [_ AB]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "Mai 2 Cyclic: Cyclic permutation of threats and
  mates across tries 1.{Tr1}?, 1.{Tr2}?, and key 1.{K}!
  (threat 2.{EF}#, defenses 2.{AB}#)."
---
try (AB) [CD _ _]
try (CD) [_ EF _]
key (EF) [_ _ AB]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "Mai 2 Cyclic: Cyclic permutation of threats and
  mates across tries 1.{Tr1}?, 1.{Tr2}?, and key 1.{K}!
  (threat 2.{EF}#, defenses 2.{AB}#)."
```

### Reeves Cycle
**Enum**: `NamedTheme::ReevessCycle`

Cyclic permutation of threats and mates across three phases: Try 1 threatens A (1...a 2.B#), Try 2 threatens B (1...b 2.C#), Key threatens C (1...a 2.A#).

```thema
try (A) [B _]
try (B) [_ C]
key (C) [A _]
subsumes ChangedPlay, ThreatKey
story "Reeves cycle: Cyclic permutation of threats
  and mates across Try 1.{Tr1}? (2.{A}#), Try 1.{Tr2}?
  (2.{B}#), and Key 1.{K}! (2.{C}#)."
```

### Complete Djurasevic
**Enum**: `NamedTheme::DurasevicComplete`

Complete cyclic shift between phase moves, threats, and mates against defense a: Try A threatens B (mates C), Try B threatens C (mates A), Key C threatens A (mates B).

```thema
try A (B) [C]
try B (C) [A]
key C (A) [B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes CyclicLeGrand, Jurasevic, PseudoErokhin,
  Ukrainian, Urania, Volgograd, Zhuravlev
story "Complete Djurasevic: Full cycle of key, threat,
  and defensive mate across Try 1.{A}? (threat 2.{B}#),
  Try 1.{B}? (threat 2.{C}#), and Key 1.{C}!
  (threat 2.{A}#) against defense 1...{a}."
```

### Pseudo-Djurasevic
**Enum**: `NamedTheme::PseudoDurasevic`

Pseudo-Djurasevic shift across two phases: Try A threatens B (1...a 2.C#); subsequent phase plays B, threatens C (1...b 2.A#).

```thema
try A (B) [C _]
+any B (C) [_ A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ThreatAntiReversal, ThreatKey
story "Pseudo-Djurasevic: Transferred play across
  Try 1.{A}? (threat 2.{B}#, 1...{a} 2.{C}#) and 1.{B}
  (threat 2.{C}#, 1...{b} 2.{A}#)."
```

### Pseudo-Djurasevic Complete
**Enum**: `NamedTheme::PseudoDurasevicComplete`

Complete 3-phase pseudo-Djurasevic cycle: Try A threatens B (1...a 2.C#), Try B threatens C (1...b 2.A#), Key C threatens A (1...b 2.B#).

```thema
try A (B) [C _]
try B (C) [_ A]
key C (A) [_ B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Jurasevic, Urania, Zhuravlev
story "Pseudo-Djurasevic Complete: Complete cyclic
  transfer of mates across Try 1.{A}?, Try 1.{B}?,
  and Key 1.{C}! (threat 2.{A}#, 1...{b} 2.{B}#)."
```

### Erokhin Double
**Enum**: `NamedTheme::ErokhinDouble`

Double Erokhin reciprocal shift: Try A threatens B (answers defenses a, b with C, D); Key C threatens D (answers defenses a, b with B, A).

```thema
try A (B) [C D]
key C (D) [B A]
subsumes AntiReversal, ChangedPlay, Erokhin, Isaev,
  PseudoLeGrand, PseudoSalazar, ThreatKey, VladimirovCC2
story "Erokhin Double: Double reciprocal shift across
  Try 1.{A}? (threat 2.{B}#, defenses 1...{a} 2.{C}#,
  1...{b} 2.{D}#) and Key 1.{C}! (threat 2.{D}#,
  defenses 1...{a} 2.{B}#, 1...{b} 2.{A}#)."
```

### Erokhin
**Enum**: `NamedTheme::Erokhin`

Erokhin theme: Try B answers defense a with mate A; Key K threatens A and answers defense a with mate B (or Try threatens A and mates B, followed by phase move B mating A).

```thema
try B [A]
key K (A) [B]
with -refutation_is_check
story "Erokhin: Try 1.{B}? answers defense 1...{a} with
  2.{A}#; Key 1.{K}! threatens 2.{A}# and answers defense
  1...{a} with 2.{B}#."
---
try (A) [B]
+any B [A]
with -refutation_is_check -match_threat_count
  -capture_try_piece
story "Erokhin: Try 1.{Tr}? threatens 2.{A}# and answers
  1...{a} with 2.{B}#; subsequent phase plays 1.{B}! and
  answers 1...{a} with 2.{A}#."
---
try Tr (A) [B _]
key B [A Tr]
with -refutation_is_check -match_threat_count
  -capture_try_piece
subsumes ChangedMate
story "Erokhin: Try 1.{Tr}? (threat 2.{A}#,
  1...{a} 2.{B}#) leads to Key 1.{B}!, where 2.{A}# and
  2.{Tr}# appear as variation checkmates."
```

### Cyclic Refutations
**Enum**: `NamedTheme::CyclicRefutations`

Three tries are cyclically refuted by Black defenses a, b, c, all three of which are answered by mates A, B, C in the Key.

```thema
try [! _ _]
try [_ ! _]
try [_ _ !]
key [A* B* C*]
subsumes ChangedPlay, Makrava
story "Cyclic Refutations: Tries 1.{Tr1}?, 1.{Tr2}?,
  and 1.{Tr3}? are cyclically refuted by defenses
  1...{a}!, 1...{b}!, and 1...{c}!, resolved by key
  1.{K}!{threat_clause}: 1...{a} 2.{A}#, 1...{b} 2.{B}#,
  1...{c} 2.{C}#."
```

### Cyclic Refutations Complete
**Enum**: `NamedTheme::CyclicRefutationsComplete`

Complete cyclic refutations across 3 tries—Try 1 (D, E, !), Try 2 (F, !, G), Try 3 (!, H, I)—resolved in the Key with mates A, B, C against defenses a, b, c.

```thema
try [D* E* !]
try [F* ! G*]
try [! H* I*]
key [A* B* C*]
subsumes ChangedPlay, CyclicRefutationsIncomplete, Makrava
story "Complete Cyclic Refutations: Tries 1.{Tr1}?,
  1.{Tr2}?, and 1.{Tr3}? with complete cyclic refutations
  across defenses 1...{a}!, 1...{b}!, and 1...{c}!,
  resolved by key 1.{K}!{threat_clause}: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Cyclic Refutations Incomplete
**Enum**: `NamedTheme::CyclicRefutationsIncomplete`

Incomplete cyclic refutations across 3 tries—Try 1 (D, _, !), Try 2 (!, E, _), Try 3 (_, !, F)—resolved in the Key with mates A, B, C against defenses a, b, c.

```thema
try [D* _ !]
try [! E* _]
try [_ ! F*]
key [A* B* C*]
subsumes ChangedMate, CyclicRefutations
story "Incomplete Cyclic Refutations: Tries 1.{Tr1}?,
  1.{Tr2}?, and 1.{Tr3}? cyclically refuted across
  defenses 1...{a}!, 1...{b}!, and 1...{c}!,
  resolved by key 1.{K}!{threat_clause}: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Dombrovsky
**Enum**: `NamedTheme::Dombrovsky` · *Alias*: Dombrovskis

Spelling variant of Dombrovskis: tries threaten A and B (refuted by defenses a and b); Key answers defenses a and b with mates A and B.

```thema
try (A) [! _]
try (B) [_ !]
key [A B]
story "Dombrovsky: Changed play across defenses:
  1...{a} 2.{A}#, 1...{b} 2.{B}#"
```

### Zilahi
**Enum**: `NamedTheme::Zilahi` · *Alias*: Zilahi theme

Cyclic sacrifice of White pieces in checkmating lines across phases.

```thema
def [a:x@B.from b:x@A.from]
key [A B]
where A.from != B.from, A != B
story "Zilahi: Key 1.{K}!{threat_clause} features
  reciprocal sacrifice and capture of the thematic mating
  pieces: 1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Caprice
**Enum**: `NamedTheme::Caprice`

Try threat X is refuted by defense a; Key neutralizes or deflects a's piece and realizes X as a variation mate.

```thema
try T (X) [! B?]
key K [A? X]
where (K.to == a.from || K.to == a.to || K.from == a.to
    || b.from == a.from)
story "Caprice: Try 1.{T}? (threat 2.{X}#) is refuted
  by 1...{a}!; Key 1.{K}!{threat_clause} neutralizes
  1...{a} and realizes 2.{X}# against 1...{b}."
---
try T (AB) [A B !]
key K (Z)
where same_piece(A, B),
  (same_piece(A, Z) || T.threat_count > 2)
with -match_threat_count -capture_try_piece
  -single_refutation
story "Caprice: Try 1.{T}? (threats 2.{A}#, 2.{B}#)
  separates its threats against 1...{a} and 1...{b},
  refuted by 1...{c}!."
---
try T (XY) [- -]
key K [X Y]
where T.threat_count == 2
with -match_threat_count -match_mate_count
story "Caprice: Try 1.{T}? (double threat 2.{X}#,
  2.{Y}#) realizes both threats as variation mates
  after Key 1.{K}!{threat_clause}: 1...{a} 2.{X}# and
  1...{b} 2.{Y}#."
---
try T (XY) [_ _]
key K [A B]
where T.threat_count == 2, a.to == X.to, b.to == Y.to
with -match_threat_count -match_mate_count
story "Caprice: Try 1.{T}? (double threat 2.{X}#, 2.{Y}#);
  after Key 1.{K}!{threat_clause}, defenses 1...{a} and
  1...{b} to the threat squares allow 2.{A}# and 2.{B}#."
---
try T [A B !]
key K [C D _]
where K.threat_count > 0
with -match_threat_count -match_mate_count
  -no_threats_few_replies -no_threats_sparse_mates
  -single_refutation
story "Caprice: Try 1.{T}? (1...{a} 2.{A}#,
  1...{b} 2.{B}#, refuted by 1...{c}!) is resolved
  with changed mates by Key 1.{K}!{threat_clause}:
  1...{a} 2.{C}# and 1...{b} 2.{D}#."
---
try Tr1 (X) [Y !]
try Tr2 (XY) [! _]
key K (Y) [X _]
where Tr1.threat_count == 1, Tr2.threat_count == 2
with -match_threat_count -match_mate_count
story "Caprice: Defense 1...{a} (answered by 2.{Y}#
  in Try 1.{Tr1}?) transfers to refute Try 1.{Tr2}?,
  and is met by 2.{X}# after Key 1.{K}! (threat 2.{Y}#)."
---
try Tr1 [A* !]
try Tr2 [! B*]
key K
where same_square(a, b), a.from != b.from,
  Tr1.threat_count > 0, Tr2.threat_count > 0
with -single_refutation -capture_try_piece
  -match_threat_count -match_mate_count
story "Caprice: Tries 1.{Tr1}? and 1.{Tr2}? are
  reciprocally answered and refuted by defenses 1...{a}
  and 1...{b} on {a.to}."
```

### Reciprocal Dombrovskis
**Enum**: `NamedTheme::DombrovskisReciprocal`

Two tries with threats A and B refuted by a and b; Try 1 answers b with mate B and Try 2 answers a with mate A.

```thema
try (A) [! B]
try (B) [A !]
key K
story "Reciprocal Dombrovskis: Tries 1.{Tr1}?
  (threat 2.{A}#, refuted by 1...{a}!, 1...{b} 2.{B}#)
  and 1.{Tr2}? (threat 2.{B}#, 1...{a} 2.{A}#,
  refuted by 1...{b}!) reciprocally answer each other's
  refutations before Key 1.{K}!{threat_clause}."
```

### Secondary Dombrovskis
**Enum**: `NamedTheme::SecondaryDombrovskis`

Secondary (defense-level) Dombrovskis: a Black piece's random move a allows general mate A in virtual play while correction move b avoids A; in a subsequent phase, correction move b is answered by mate A while random move a receives changed mate C.

```thema
vir [A _]
+any [C A]
where same_piece(a, b)
subsumes ChangedMate, TransferredMates
story "Secondary Dombrovskis: Random move 1...{a} allowed
  general mate 2.{A}# in {phase1} (while correction
  1...{b} avoided it); in {phase2}, correction 1...{b}
  is met by 2.{A}# while 1...{a} receives changed
  mate 2.{C}#."
```

### King's Le Grand
**Enum**: `NamedTheme::KingsLeGrand`

Le Grand or Pseudo-Le Grand reciprocal threat-mate transference where the thematic Black defense is a move of the Black King.

```thema
def [a:K]
try (A) [B]
key (B) [A]
subsumes KingFlight, Legrand, ThreatKey, TransferredMates
story "King's Le Grand: Reciprocal exchange of threats
  and mates against Black King flight 1...{a} across
  Try 1.{Tr}? (threat 2.{A}#, 1...{a} 2.{B}#) and
  Key 1.{K}! (threat 2.{B}#, 1...{a} 2.{A}#)."
```

### Soviet-French theme
**Enum**: `NamedTheme::SovietFrench`

Flight-giving key combined with Dombrovskis threat-refutation transference across two tries and the key.

```thema
try (A) [! _]
try (B) [_ !]
key K [A B]
where K.flights_given > 0
subsumes Dombrovskis, Dombrovsky, FlightGivingKey,
  TransferredMates
story "Soviet-French theme: Flight-giving
  Key 1.{K}!{threat_clause} resolves Dombrovskis tries
  1.{Tr1}? (threat 2.{A}#, refuted by 1...{a}!) and
  1.{Tr2}? (threat 2.{B}#, refuted by 1...{b}!) with
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Ukrainian
**Enum**: `NamedTheme::Ukrainian` · *Alias*: Ukrainian theme

Three-phase cyclic shift between threats and mates against the same Black defense (Try 1 threatens A, mates B; Try 2 threatens B, mates C; Key threatens C, mates A).

```thema
try (A) [B]
try (B) [C]
key (C) [A]
subsumes ChangedPlay, ThreatKey, TransferredMates
story "Ukrainian theme: Three-phase cyclic
  exchange of threats and mates against 1...{a}:
  Try 1.{Tr1}? (threat 2.{A}#, 1...{a} 2.{B}#),
  Try 1.{Tr2}? (threat 2.{B}#, 1...{a} 2.{C}#),
  and Key 1.{K}! (threat 2.{C}#, 1...{a} 2.{A}#)."
```

### Cyclic Pseudo-Le Grand
**Enum**: `NamedTheme::CyclicPseudoLeGrand`

Tries threaten A (1...b 2.B#) and B (1...a 2.A#) individually and AB combined, while the Key threatens C and answers Black defenses a and b with A and B.

```thema
try (A) [- -]
try (B) [- -]
try (AB) [- -]
key (C) [A B]
subsumes Barnes, DoubleThreat, PseudoLeGrand, Rudenko,
  ThreatKey, TransferredMates
story "Cyclic Pseudo-Le Grand: Tries threatening 2.{A}#
  (1...{b} 2.{B}#), 2.{B}# (1...{a} 2.{A}#), and double
  threat 2.{AB}# culminate in Key 1.{K}! (threat 2.{C}#),
  transferring 2.{A}# and 2.{B}# to variations 1...{a}
  and 1...{b}."
```

### Anti-Dombrovskis
**Enum**: `NamedTheme::AntiDombrovskis`

Try 1 threatens A; Try 2 answers defense a with A; Key answers defense a with a changed mate C.

```thema
try (A) [B]
try (D) [A]
key (E) [C]
subsumes ChangedPlay, ThreatKey
story "Anti-Dombrovskis: Threat 2.{A}# from Try 1.{Tr1}?
  becomes the variation mate against 1...{a}
  in Try 1.{Tr2}?, before changing to 2.{C}# after
  Key 1.{K}! (threat 2.{E}#)."
```

### Anti-Le Grand
**Enum**: `NamedTheme::AntiLeGrand`

Try 1 threatens AB; Try 2 threatens B and answers defense b with A; Key threatens A, answers defense a with B, and answers defense b with changed mate C.

```thema
try (AB) [_ _]
try (B) [_ A]
key (A) [B C]
subsumes Barnes, ChangedPlay, DoubleThreat, Isaev,
  PseudoLeGrand, ThreatKey
story "Anti-Le Grand: Double threat 2.{AB}#
  in Try 1.{Tr1}? separates into threat 2.{B}# / mate
  2.{A}# in Try 1.{Tr2}?, while Key 1.{K}! threatens
  2.{A}#, meets 1...{a} with 2.{B}#, and meets 1...{b}
  with changed mate 2.{C}#."
```

### Cyclic Kiss
**Enum**: `NamedTheme::KissCyclic`

Three-phase cyclic Kiss where the threat in each phase equals a variation mate from the preceding phase.

```thema
try (A) [B _ _]
try (B) [_ C _]
key (C) [_ _ A]
subsumes ThreatKey, TransferredMates
story "Cyclic Kiss: Three-phase threat-mate cycle
  across Try 1.{Tr1}? (threat 2.{A}#, 1...{a} 2.{B}#),
  Try 1.{Tr2}? (threat 2.{B}#, 1...{b} 2.{C}#),
  and Key 1.{K}! (threat 2.{C}#, 1...{c} 2.{A}#)."
```

### Anti-Lacny
**Enum**: `NamedTheme::AntiLacny`

Three-phase cyclic shift of two mates A, B and a refutation across three Black defenses.

```thema
vir [A B !]
try [! A B]
try [B ! A]
key [C D E]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes RukhlisCyclic
story "Anti-Lacny: Cyclic shift of mates 2.{A}#,
  2.{B}# and refutations across 1...{a}, 1...{b},
  1...{c} in virtual play and Key 1.{K}!."
```

### Cyclic Threat Reversal
**Enum**: `NamedTheme::CyclicThreatReversal`

Three-phase cyclic Threat Reversal where threats A, B, C and variation mates B, C, A cycle across three distinct defenses.

```thema
try (A) [B _ _]
try (B) [_ C _]
key (C) [_ _ A]
subsumes ChangedPlay, KissCyclic, PseudoCyclicLeGrand
story "Cyclic Threat Reversal: Threats 2.{A}#, 2.{B}#,
  2.{C}# and variation mates cycle across 1...{a},
  1...{b}, 1...{c}."
```

### Double Dombrovskis
**Enum**: `NamedTheme::DoubleDombrovskis` · *Alias*: 4-fold Dombrovskis

Four tries with distinct threats A, B, C, D refuted by a, b, c, d, all four threats appearing as variation mates after a, b, c, d in the key.

```thema
try (A) [! _ _ _]
try (B) [_ ! _ _]
try (C) [_ _ ! _]
try (D) [_ _ _ !]
key [A B C D]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay, Dad, Dombrovskis, Dombrovsky
story "Double Dombrovskis: Four try threats (2.{A}#,
  2.{B}#, 2.{C}#, 2.{D}#) refuted by 1...{a}!, 1...{b}!,
  1...{c}!, 1...{d}! become the four variation mates after
  Key 1.{K}!{threat_clause}."
```

### Triple Hannelius
**Enum**: `NamedTheme::TripleHannelius`

Three tries with threats A, B, C refuted by a, b, c, answered in the key by the cyclic permutation B, C, A.

```thema
try (A) [! _ _]
try (B) [_ ! _]
try (C) [_ _ !]
key [B C A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Dad
story "Triple Hannelius: Try threats 2.{A}# (refuted
  by 1...{a}!), 2.{B}# (refuted by 1...{b}!),
  and 2.{C}# (refuted by 1...{c}!) cycle after
  Key 1.{K}!{threat_clause}: 1...{a} 2.{B}#,
  1...{b} 2.{C}#, 1...{c} 2.{A}#."
```

### Reciprocal Banny
**Enum**: `NamedTheme::ReciprocalBanny`

Tries 1.A? (refuted by a!) and 1.B? (refuted by b!) have their first moves appear reciprocally against a and b in the key.

```thema
try A [! _]
try B [_ !]
key [B A]
subsumes Vladimirov
story "Reciprocal Banny: Try moves 1.{A}? (refuted
  by 1...{a}!) and 1.{B}? (refuted by 1...{b}!)
  appear reciprocally after Key 1.{K}!{threat_clause}:
  1...{a} 2.{B}# and 1...{b} 2.{A}#."
```

### Reciprocal Vladimirov
**Enum**: `NamedTheme::VladimirovReciprocal`

Try 1.A? (refuted by a!, mating with B after b) and Try 1.B? (refuted by b!, mating with A after a) are united in the key with 1...a 2.A# and 1...b 2.B#.

```thema
try A [! B]
try B [A !]
key [A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes MoscowTheme, PseudoSalazar, VladimirovIdeal
story "Reciprocal Vladimirov: Tries 1.{A}?
  (1...{b} 2.{B}#, refuted by 1...{a}!) and 1.{B}?
  (1...{a} 2.{A}#, refuted by 1...{b}!) unite after
  Key 1.{K}!{threat_clause}: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Pseudo Erokhin
**Enum**: `NamedTheme::PseudoErokhin`

In Phase 1, White plays 1.A (threat 2.B#) with variation 1...a 2.C#; in Phase 2, White plays 1.C (threat 2.D#) with variation 1...a 2.B#.

```thema
try A (B) [C]
+any C (D) [B]
where distinct(A, B, C)
with -match_threat_count
subsumes Erokhin, TransferredMates
story "Pseudo Erokhin: Try 1.{A}? (threat 2.{B}#;
  1...{a} 2.{C}#) shifts into 1.{C} (threat 2.{D}#;
  1...{a} 2.{B}#)."
```

### Cyclic Herpai
**Enum**: `NamedTheme::CyclicHerpai`

Three Black defenses on the same square form a cycle of mates/refutations in tries and allow three distinct mates in the key.

```thema
try [A ! _]
try [_ B !]
key [A B C]
where same_square(a, b, c),
  distinct(a.from, b.from, c.from)
subsumes ArrivalCorrection
story "Cyclic Herpai: On {a.to}, tries fail to 1...{b}!
  and 1...{c}! while Key 1.{K}! unites 1...{a} 2.{A}#,
  1...{b} 2.{B}#, and 1...{c} 2.{C}#."
```

### Hermanson theme
**Enum**: `NamedTheme::Hermanson` · *Alias*: Hermanson

Two tries and the Key share the same threat T while cyclically shifting mates A, B, C across defenses a and b (A, B / B, C / C, A).

```thema
try (T) [A B]
try (T) [B C]
key (T) [C A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Brabec3, Lacny, RiceCycle, ZagoruikoCyclic
story "Hermanson theme: With common threat 2.{T}#, Try
  1.{Tr1}?, Try 1.{Tr2}?, and Key 1.{K}! cyclically shift
  2.{A}#, 2.{B}#, and 2.{C}# across 1...{a} and 1...{b}."
```

### Poltava theme
**Enum**: `NamedTheme::Poltava` · *Alias*: Poltava

A try and a multi-flight-giving key by the same White piece produce changed mates against Black King flights and captures (Caprice + multi-flight key).

```thema
try Tr [A B]
key K [C D]
where same_piece(Tr, K), Tr.to != K.to,
  K.flights_given >= 2
subsumes ChangedPlay, FlightGivingKey
story "Poltava theme: Try 1.{Tr}? (2.{A}#, 2.{B}#) and
  multi-flight Key 1.{K}! (2.{C}#, 2.{D}#) by the same
  White {K.role} change the mates."
```

### Amazon theme
**Enum**: `NamedTheme::Amazon` · *Alias*: Amazon

A try and the key exhibit a three-variation Lacny cyclic shift where all three thematic mates are delivered by the White Queen.

```thema
try [A:Q B:Q C:Q]
key [B C A]
where same_piece(A, B, C), distinct(A.to, B.to, C.to)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes AntiCarousel, ChangedPlay, CounterCarousel
story "Amazon theme: White's Queen cyclically shifts
  three mates between Try 1.{Tr}? (1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#) and Key 1.{K}! (1...{a}
  2.{B}#, 1...{b} 2.{C}#, 1...{c} 2.{A}#)."
```

### Surkov-Slesarenko combination
**Enum**: `NamedTheme::SurkovSlesarenko`

Try 1.A? (threat 2.B#) answers defenses a and b with 2.C# and 2.D#; the key threatens (CD) and answers a and b with 2.A# and 2.B# (or reciprocal multi-phase combination of Erokhin, Le Grand, and Anti-Reversal).

```thema
try A (B) [C D]
try C (D) [A _]
key D (C) [_ B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes AntiReversal, ChangedPlay, Isaev, Legrand,
  PseudoErokhin, PseudoLeGrand, Salazar, ThreatReversal,
  Urania
story "Surkov-Slesarenko combination: Try 1.{A}? (threat
  2.{B}#; 2.{C}#, 2.{D}#), Try 1.{C}? (threat 2.{D}#;
  2.{A}#), and Key 1.{D}! (threat 2.{C}#; 2.{B}#)."
---
try A (B) [C D]
key K (CD) [A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes AntiReversal, ChangedPlay, Erokhin, Legrand,
  PseudoErokhin, PseudoLeGrand, Rudenko
story "Surkov-Slesarenko combination:
  Try 1.{A}? (threat 2.{B}#; 1...{a} 2.{C}#,
  1...{b} 2.{D}#) and Key 1.{K}! (threats 2.{C}#, 2.{D}#;
  1...{a} 2.{A}#, 1...{b} 2.{B}#)."
---
try Tr (AB) [C D]
key C (D) [A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes AntiReversal, ChangedPlay, Erokhin, Legrand,
  PseudoErokhin, PseudoLeGrand, Rudenko
story "Surkov-Slesarenko combination: Try 1.{Tr}? (threats
  2.{A}#, 2.{B}#; 1...{a} 2.{C}#, 1...{b} 2.{D}#) and Key
  1.{C}! (threat 2.{D}#; 1...{a} 2.{A}#, 1...{b} 2.{B}#)."
```

### Dombro-Zagoruiko
**Enum**: `NamedTheme::DombroZagoruiko`

Set play has mates C and D after defenses a and b; two tries threaten A and B (refuted by a and b respectively); the key answers a and b with A and B (combining Dombrovskis and 3-phase Zagoruiko).

```thema
vir [C D]
try (A) [! _]
try (B) [_ !]
key [A B]
subsumes ChangedPlay, Dombrovskis, Dombrovsky
story "Dombro-Zagoruiko: Set play (1...{a} 2.{C}#,
  1...{b} 2.{D}#) and Dombrovskis tries (threats 2.{A}#,
  2.{B}#) culminate in Key 1.{K}! (1...{a} 2.{A}#,
  1...{b} 2.{B}#)."
```

### Shedey-Lacny
**Enum**: `NamedTheme::ShedeyLacny`

A three-move cycle (A, B, C) between virtual play and the key where the threat and two defensive mates cyclically shift (Shedey cycle + Lacny).

```thema
vir (A) [B C]
key (B) [C A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Lacny, ShedeyCycle
story "Shedey-Lacny: Mates 2.{A}#, 2.{B}#,
  2.{C}# cycle across threat and defenses 1...{a},
  1...{b} between virtual play (threat 2.{A}#, 2.{B}#,
  2.{C}#) and Key 1.{K}! (threat 2.{B}#, 2.{C}#, 2.{A}#)."
---
vir [A B C]
key (A) [B C A]
subsumes Lacny, ShedeyCycle
story "Shedey-Lacny: Virtual mates 2.{A}#, 2.{B}#,
  2.{C}# shift after Key 1.{K}! (threat 2.{A}#) into
  1...{a} 2.{B}#, 1...{b} 2.{C}#, and 1...{c} 2.{A}#."
```

### Complete Shedey cycle
**Enum**: `NamedTheme::CompleteShedeyCycle`

Across two tries and the key, three White moves A, B, C form a complete cycle between threats and variation mates against two Black defenses.

```thema
try (A) [B C]
try (B) [C A]
key (C) [A B]
with -match_threat_count
subsumes Brabec3, Isaev, PseudoLeGrand, RiceCycle,
  ShedeyCycle, Ukrainian, ZagoruikoCyclic
story "Complete Shedey cycle: Threats and mates (2.{A}#,
  2.{B}#, 2.{C}#) cycle completely across Try 1.{Tr1}?,
  Try 1.{Tr2}?, and Key 1.{K}!."
```

---

## 05. Multi-Threat Separation & Named Try-Play Systems

*Tries and keys featuring multiple simultaneous threats separated by defenses (Fleck, Barnes) and classical try-play composer themes.*

### Barnes
**Enum**: `NamedTheme::Barnes`

Multiple threats AB in one phase T1 separated into individual threats A and B in phases T2 and T3.

```thema
+any T1 (AB)
+any T2 (A)
+any T3 (B)
with -refutation_is_check -capture_try_piece
  -single_refutation -flight_from_check -sparse_mates
  -few_replies
story "Barnes threat separation: Combined double threat
  2.{AB}# in one phase is separated into individual
  threats 2.{A}# and 2.{B}# in other phases after
  key 1.{key}!."
```

### Arnhem
**Enum**: `NamedTheme::Arnhem`

Try 1 answers defense a with mate A (refuted by b); Try 2 answers defense b with mate A (refuted by a); solved by Key K.

```thema
try [A !]
try [! A]
key K
story "Arnhem: Tries 1.{Tr1}? (1...{a} 2.{A}#, refuted
  by 1...{b}!) and 1.{Tr2}? (1...{b} 2.{A}#, refuted
  by 1...{a}!) reciprocate mate 2.{A}# and refutation,
  resolved by key 1.{K}!{threat_clause}."
```

### Kiss
**Enum**: `NamedTheme::Kiss`

Kiss theme: Try A answers defenses a and b with mates B and C; Key B answers defenses a and b with mates C and A.

```thema
try A [B C]
key B [C A]
with -match_threat_count -match_mate_count
subsumes ChangedMate, PseudoSalazar
story "Kiss: Cyclic change across try 1.{A}?
  (defenses 1...{a} 2.{B}#, 1...{b} 2.{C}#) and key
  1.{B}!{threat_clause} (defenses 1...{a} 2.{C}#,
  1...{b} 2.{A}#)."
```

### Mäkihovi
**Enum**: `NamedTheme::Makihovi` · *Alias*: Makihovi

Defense dual separation across three phases: dual mate AB against defense a in virtual phase V is separated into mate A in Try Tr and mate B in Key K.

```thema
vir V [AB]
try Tr [A]
key K [B]
where A.from != V.to, B.from != V.to, A.from != Tr.to,
  B.from != K.to
subsumes ChangedPlay
story "Mäkihovi: Dual mate 2.{AB}# in {phase1} is
  separated into 2.{A}# in try 1.{Tr}? and 2.{B}# after
  key 1.{K}!{threat_clause} against defense 1...{a}."
```

### Robert
**Enum**: `NamedTheme::RobertTheme`

Robert theme: dual mate AB against defense a in a try is separated in the Key across defenses b and c as mates A and B (with mate C against a).

```thema
try [AB _ _]
key [C A B]
subsumes ChangedMate
story "Robert theme: Dual mate 2.{AB}# in try
  1.{Tr}? is separated across defenses after key
  1.{K}!{threat_clause}: 1...{a} 2.{C}#, 1...{b} 2.{A}#,
  1...{c} 2.{B}#."
```

### Žuk
**Enum**: `NamedTheme::Zuk` · *Alias*: Zuk

Try has double threat AB refuted by defenses a and b; Key answers defenses with mates A and B.

```thema
try (AB) [! !]
key [A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Rudenko
story "Žuk: Try 1.{Tr}? has double threat 2.{AB}# refuted
  by 1...{a}! and 1...{b}!; Key 1.{K}!{threat_clause}
  separates these threats into defensive mates:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Mochalkin
**Enum**: `NamedTheme::Mochalkin`

Mochalkin theme: Try has double threat AB (with mates C, D against defenses a, b); Key threatens C and answers defenses a, b with mates A, B.

```thema
try (AB) [C D]
key (C) [A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes RudenkoReversal, ThreatKey
story "Mochalkin: Try 1.{Tr}? carries double threat
  2.{AB}# (answered by 1...{a} 2.{C}# and 1...{b} 2.{D}#);
  Key 1.{K}! threatens 2.{C}# and converts the try
  threats into defensive mates: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Odessa
**Enum**: `NamedTheme::Odessa`

Try has double threat AB (with mates C, D against defenses a, b); Key threatens CD and transfers A, B into variation mates.

```thema
try (AB) [C D _ _]
key (CD) [_ _ A B]
subsumes KarlstromFleck, Rudenko, Shanshin,
  TransferredMates
story "Odessa: Try 1.{Tr}? carries double threat 2.{AB}#
  (defended by 1...{a} 2.{C}# and 1...{b} 2.{D}#); Key
  1.{K}! threatens 2.{CD}# and transfers the try threats
  to new defenses: 1...{c} 2.{A}# and 1...{d} 2.{B}#."
---
try (AB) [C D]
key (CD) [A B]
subsumes KarlstromFleck, Rudenko, Shanshin,
  TransferredMates
story "Odessa: Try 1.{Tr}? (double threat 2.{AB}#, 1...{a}
  2.{C}#, 1...{b} 2.{D}#) and Key 1.{K}! (double threat
  2.{CD}#, 1...{a} 2.{A}#, 1...{b} 2.{B}#) reciprocally
  exchange double threats and variation mates."
```

### Mate Transference
**Enum**: `NamedTheme::MateTransference`

Mate transference: checkmate A transfers across phases from a try threat or defense a to answer defense a or b in the Key.

```thema
set [!A]
try (A) [_]
key (T) [A!@a]
story "Mate transference: Mate 2.{A}# transferred
  from try play into Key 1.{K}! (threat 2.{T}#):
  defense 1...{a} met by 2.{A}#."
---
try Tr (A) [_]
key K (-) [A!@a]
where !(same_piece(Tr, K) && A.from == Tr.to),
  Tr.threat_count <= 2,
  (A.mate_count == 1 || a.self_block)
with -match_threat_count -match_mate_count
story "Mate transference: Try threat 2.{A}# becomes
  an actual checkmate against defense 1...{a}
  in the solution (Key 1.{K}!)."
---
set [A B]
key [C A]
where K.threat_count <= 1,
  !(same_piece(a, b) && ((a.unguards(A) && b.unguards(A))
    || (a.opens_line() && b.opens_line()) || (A.slider
    && a.opens_line(WK) && b.opens_line(WK)) || (A.slider
    && !a.capture && !b.capture
    && collinear(a.from, a.to, b.to))))
story "Mate transference: Set-play mate against defense
  1...{a} transfers to answer 1...{b} in the solution:
  2.{A}# (Key 1.{K}!{threat_clause})."
---
vir [A C]
+any [B A]
where K.threat_count <= 1,
  !(same_piece(a, b) && (A.slider && !a.capture
    && !b.capture && collinear(a.from, a.to, b.to)))
with -no_threats_sparse_mates -no_threats_few_replies
  -match_threat_count
story "Mate transference: Key 1.{K}!{threat_clause}.
  Mating reply 2.{A}# (against 1...{a}) is transferred
  to answer defense 1...{b}."
---
vir [A -]
+any [B A]
where K.threat_count <= 1,
  !(same_piece(a, b) && ((a.unguards(A) && b.unguards(A))
    || (a.opens_line() && b.opens_line()) || (A.slider
    && a.opens_line(WK) && b.opens_line(WK)) || (A.slider
    && !a.capture && !b.capture
    && collinear(a.from, a.to, b.to))))
with -no_threats_sparse_mates -no_threats_few_replies
  -match_threat_count
story "Mate transference: Key 1.{K}!{threat_clause}.
  Mating reply 2.{A}# (against 1...{a}) is transferred
  to answer defense 1...{b}."
---
vir [A B - -]
key [- - A B]
story "Mate transference: Mates 2.{A}# and 2.{B}#
  transfer from virtual play to answer 1...{c} and 1...{d}
  in the solution (Key 1.{K}!{threat_clause})."
---
set [A B - -]
key (XY) [C* D* A B]
where A != C, B != D
with -match_threat_count -match_mate_count
story "Mate transference: Set-play mates 2.{A}# and 2.{B}#
  against 1...{a} and 1...{b} transfer to answer 1...{c}
  and 1...{d} after Key 1.{K}!{threat_clause}."
---
set [A:P:= B:P:=]
key [C:P:= D:P:=]
where same_piece(A, B, C, D), A.promotion == D.promotion,
  B.promotion == C.promotion, A.promotion != B.promotion
with -match_mate_count
story "Mate transference: Set-play promotion mates
  2.{A}# and 2.{B}# against 1...{a} and 1...{b}
  reciprocally transfer after Key 1.{K}!{threat_clause}:
  1...{a} 2.{C}# and 1...{b} 2.{D}#."
---
vir [A -]
+any [- A]
where K.threat_count <= 1,
  !(same_piece(a, b) && ((a.unguards(A) && b.unguards(A))
    || (a.capture == b.capture && a.opens_line()
    && b.opens_line()) || (A.slider && a.opens_line(WK)
    && b.opens_line(WK)) || (A.slider && !a.capture
    && !b.capture && collinear(a.from, a.to, b.to))))
with -no_threats_sparse_mates -no_threats_few_replies
  -match_threat_count
story "Mate transference: Key 1.{K}!{threat_clause}.
  Mating reply 2.{A}# (against 1...{a}) is transferred
  to answer defense 1...{b}."
---
set [A -]
key [A* A]
where !same_piece(a, b), (a, b).role != 'K',
  K.threat_count <= 1, a.self_block, K.flights_given > 0
with -match_mate_count
story "Mate transference: Set-play mate 2.{A}# against
  1...{a} transfers to also answer 1...{b} after
  Key 1.{K}!{threat_clause}."
```

### Volgograd
**Enum**: `NamedTheme::Volgograd`

Volgograd theme: Try A threatens B and answers defense a with mate C; Key K threatens A and answers defense a with mate B.

```thema
try A (B) [C]
key K (A) [B]
subsumes ChangedMate, ThreatAntiReversal, ThreatKey
story "Volgograd: Cyclic shift between try 1.{A}?
  (threat 2.{B}#, defense 1...{a} 2.{C}#) and key 1.{K}!
  (threat 2.{A}#, defense 1...{a} 2.{B}#)."
```

### Lender Combination
**Enum**: `NamedTheme::LenderCombination`

Lender combination: Try A threatens B (answers defenses a, b with C, D); Key C threatens D (answers defenses a, b with A, B).

```thema
try A (B) [C D]
key C (D) [A B]
subsumes ChangedPlay, Legrand, Salazar, ThreatKey,
  TransferredMates, VladimirovCC2
story "Lender combination: Try 1.{A}? (threat 2.{B}#,
  defenses 1...{a} 2.{C}#, 1...{b} 2.{D}#) and Key 1.{C}!
  (threat 2.{D}#, defenses 1...{a} 2.{A}#, 1...{b} 2.{B}#)
  reciprocally exchange threats and mates."
```

### Dad
**Enum**: `NamedTheme::Dad`

Dad theme: threats A, B, C from three separate tries are united into variation mates A, B, C against defenses a, b, c in the Key.

```thema
try (A) [_ _ _]
try (B) [_ _ _]
try (C) [_ _ _]
key [A B C]
story "Dad: Three separate try threats 2.{A}# (1.{Tr1}?),
  2.{B}# (1.{Tr2}?), and 2.{C}# (1.{Tr3}?) are united into
  defensive checkmates after key 1.{K}!{threat_clause}:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Mäkihovi-Robert
**Enum**: `NamedTheme::MakihoviRobert`

Synthesis of Mäkihovi dual separation and Robert reciprocal play against defense a: Try 1 has dual mate AB, Try 2 threatens A (mates B), Key threatens B (mates A).

```thema
try [AB]
try (A) [B]
key (B) [A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Legrand, Makihovi, ThreatKey
story "Mäkihovi-Robert: Synthesis of Mäkihovi
  dual separation and Robert reciprocal play
  across tries 1.{Tr1}?, 1.{Tr2}? (threat 2.{A}#,
  defense 1...{a} 2.{B}#), and key 1.{K}! (threat 2.{B}#,
  defense 1...{a} 2.{A}#)."
```

### Burmistrov
**Enum**: `NamedTheme::Burmistrov`

Burmistrov theme against defense a: Try 1 threatens AB (mates C), Try 2 threatens C (mates A), Key threatens C (mates B) (or Key threatens AB and mates C).

```thema
try (AB) [C]
try (C) [A]
key (C) [B]
subsumes ChangedPlay, DoubleThreat, ThreatKey
story "Burmistrov: Tries 1.{Tr1}?, 1.{Tr2}?,
  and key 1.{K}! (threat 2.{C}#, defense 1...{a} 2.{B}#)
  coordinate changed threats and mates."
---
try (C) [A]
try (C) [B]
key (AB) [C]
subsumes ChangedPlay, DoubleThreat, ThreatKey
story "Burmistrov: Tries 1.{Tr1}? (threat 2.{C}#,
  1...{a} 2.{A}#), 1.{Tr2}? (threat 2.{C}#,
  1...{a} 2.{B}#), and key 1.{K}! (threats 2.{AB}#,
  1...{a} 2.{C}#) coordinate changed threats and mates."
```

### Mai 2
**Enum**: `NamedTheme::Mai2`

Mai 2 theme: Try threatens double threat AB (with dual mate CD against defense a); Key threatens CD (with dual mate AB against defense b).

```thema
try (AB) [CD _]
key (CD) [_ AB]
subsumes DoubleThreat
story "Mai 2: Try 1.{Tr}? (double threat 2.{AB}#,
  defenses 2.{CD}#) and key 1.{K}! (threat 2.{CD}#,
  defenses 2.{AB}#) exchange threats and mates."
```

### Brabec 1
**Enum**: `NamedTheme::Brabec1`

Brabec theme form 1 across defenses a and b: Try 1 (A, B), Try 2 (C, -), and Key (-, D).

```thema
try [A B]
try [C -]
key [- D]
subsumes ChangedPlay
story "Brabec 1: Changed play across tries 1.{Tr1}?,
  1.{Tr2}?, and key 1.{K}!{threat_clause}: 1...{a} 2.{A}#,
  1...{b} 2.{D}#."
```

### Brabec 2
**Enum**: `NamedTheme::Brabec2`

Brabec theme form 2 across defenses a, b, c, d: virtual play (A, B, -, -), Try (-, -, A, -), and Key (-, -, -, B).

```thema
vir [A B - -]
try [- - A -]
key [- - - B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes TransferredMates
story "Brabec 2: Mate transference across {phase1},
  try 1.{Tr}?, and key 1.{K}!{threat_clause}."
```

### Brabec 3
**Enum**: `NamedTheme::Brabec3`

Brabec theme form 3 across defenses a and b: Try 1 (A, B), Try 2 (_, A), and Key (B, _).

```thema
try [A B]
try [_ A]
key [B _]
subsumes ChangedPlay, TransferredMates
story "Brabec 3: Coordinated mate transference
  across tries 1.{Tr1}?, 1.{Tr2}?, and key
  1.{K}!{threat_clause}."
```

### Brabec 4
**Enum**: `NamedTheme::Brabec4`

Brabec theme form 4 across defenses a, b, c, d: virtual play (A, B, _, _), Try (C, _, A, _), and Key (_, D, _, B).

```thema
vir [A B _ _]
try [C _ A _]
key [_ D _ B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Brabec1, TransferredMates
story "Brabec 4: Fourfold changed play across {phase1},
  try 1.{Tr}?, and key 1.{K}!{threat_clause}."
```

### Harkov
**Enum**: `NamedTheme::Harkov`

Try Tr (threat T) is refuted by two defenses a and b; Key (threat KThr) answers defenses a and b with mates A and B.

```thema
try Tr (T) [! !]
key (KThr) [A B]
where a.from != b.from, Tr.refutation_count == 2
story "Harkov: Try 1.{Tr}? (threat 2.{T}#)
  is refuted by both 1...{a}! and 1...{b}!;
  Key 1.{K}!{threat_clause} answers those defenses with
  distinct mates 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Pirrone
**Enum**: `NamedTheme::Pirrone`

Pirrone theme across defenses a, b, c, d: Try 1 (A, B, A, B), Try 2 (A, B, _), and Key (_, _, A, B).

```thema
try [A B A B]
try [A B _]
key [_ _ A B]
story "Pirrone: Recurring defenses and mates
  separated across tries 1.{Tr1}?, 1.{Tr2}?, and key
  1.{K}!{threat_clause}."
```

### Ricciardi
**Enum**: `NamedTheme::Ricciardi`

Ricciardi theme: Try 1 threatens A (refuted by b) and Try 2 threatens B (refuted by c); Key answers defenses a and b with mates A and B.

```thema
try (A) [_ ! _]
try (B) [_ _ !]
key [A B _ _]
story "Ricciardi: Tries 1.{Tr1}? and 1.{Tr2}?
  are refuted by defenses that allow mates after
  key 1.{K}!{threat_clause}: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Tver
**Enum**: `NamedTheme::Tver`

Tver theme: double threats AB and CD from two tries are united into variation mates A, B, C, D against defenses a, b, c, d in the Key.

```thema
try (AB) [_ _ _]
try (CD) [_ _ _]
key [A B C D]
subsumes DoubleThreat, Rudenko
story "Tver: Double threats from tries 1.{Tr1}? (2.{AB}#)
  and 1.{Tr2}? (2.{CD}#) are united into defensive mates
  after key 1.{K}!{threat_clause}."
```

### Double Threat
**Enum**: `NamedTheme::DoubleThreat`

The Key or Try move creates two or more simultaneous mating threats.

```thema
key K
where K.threat_count >= 2
story "Double threat: Key 1.{K}! creates two or more
  simultaneous mating threats against the Black position."
---
try T (XY) [!]
key K
story "Double threat: Try 1.{T}? creates two
  simultaneous mating threats (2.{X}# and 2.{Y}#),
  refuted by 1...{a}!."
```

### Fleck
**Enum**: `NamedTheme::Fleck` · *Alias*: Fleck theme

White threatens multiple checkmates (at least 3); Black defenses selectively separate each threat into a unique mate.

```thema
any (ABC) [A B C]
with -match_threat_count
story "Fleck theme: Key 1.{K}! threatens multiple
  checkmates 2.{ABC}#; Black defenses selectively
  separate each threat into a unique mate: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Threat key
**Enum**: `NamedTheme::ThreatKey`

The key move carries one or more direct threats of checkmate.

```thema
key K (X) [A]
where K.threat_count >= 1
story "Threat key: Key 1.{K}! introduces a direct threat
  2.{X}#, answered against 1...{a} by checkmate 2.{A}#."
```

### Ahues
**Enum**: `NamedTheme::Ahues` · *Alias*: Ahues theme

Two tries share the same threat X and are refuted by distinct defenses a and b; after the key, defenses a and b allow mates A and B.

```thema
try (X) [! _]
try (X) [_ !]
key (_) [A B]
story "Ahues: Tries 1.{Tr1}? and 1.{Tr2}? (both
  threatening 2.{X}#, refuted by 1...{a}! and 1...{b}!)
  prepare Key 1.{K}!{threat_clause}, where the refutations
  become defenses allowing mates 2.{A}# and 2.{B}#."
```

### Sushkov
**Enum**: `NamedTheme::Sushkov` · *Alias*: Sushkov theme

Reciprocal exchange of threats and variation mates between try and key across different Black defenses, or threat separation by moves to the same square.

```thema
try Tr (A) [B _]
key K (B) [_ A]
story "Sushkov: Try 1.{Tr}? (threat 2.{A}#,
  variation 1...{a} 2.{B}#) and Key 1.{K}! (threat 2.{B}#,
  variation 1...{b} 2.{A}#) reciprocally exchange threats
  and mates across different defenses."
---
try Tr (X)
key K (Y)
where same_square(Tr, K), Tr.from != K.from
with -match_threat_count -single_refutation
  -capture_try_piece -refutation_is_check
story "Sushkov: Try 1.{Tr}? (threat 2.{X}#) and Key 1.{K}!
  (threat 2.{Y}#) play to {K.to} with separated threats."
---
vir [A B - -]
key [- - A B]
story "Sushkov: Mates 2.{A}# and 2.{B}# against 1...{a}
  and 1...{b} in {phase1} are transferred to answer
  1...{c} and 1...{d} after Key 1.{K}!{threat_clause}."
```

### Moscow theme
**Enum**: `NamedTheme::MoscowTheme` · *Alias*: Moscow theme I

Two Black defenses arriving on the same square individually refute two White tries and allow distinct checkmates after the key.

```thema
try [! _]
try [_ !]
key [A B]
where same_square(a, b), a.from != b.from
with -match_threat_count -match_mate_count
story "Moscow theme: Defenses 1...{a} and 1...{b}
  arriving on {a.to} individually refute tries 1.{Tr1}?
  and 1.{Tr2}?, and allow 2.{A}# and 2.{B}# after
  Key 1.{K}!{threat_clause}."
---
try Tr1 [A !]
try Tr2 [! B]
key K [A B]
where same_square(a, b) || (same_piece(a, b)
    && same_piece(Tr1, Tr2, K))
with -few_replies -sparse_mates -match_threat_count
  -match_mate_count
story "Moscow theme: Tries 1.{Tr1}? and 1.{Tr2}?
  show reciprocal defenses and refutations;
  Key 1.{K}!{threat_clause} delivers mates:
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Transferred Mates
**Enum**: `NamedTheme::TransferredMates` · *Alias*: Transferred mates

Checkmate A appearing in one phase (as a try threat or against defense a) transfers in a subsequent phase to answer defense a or b.

```thema
set [!A]
try (A) [_]
key (T) [A!@a]
story "Transferred mates: Mate 2.{A}# transferred
  from try play into Key 1.{K}! (threat 2.{T}#):
  defense 1...{a} met by 2.{A}#."
---
try Tr (A) [_]
key K (-) [A!@a]
where !(same_piece(Tr, K) && A.from == Tr.to),
  Tr.threat_count <= 2,
  (A.mate_count == 1 || a.self_block)
with -match_threat_count -match_mate_count
story "Transferred mates: Try threat 2.{A}# becomes
  an actual checkmate against defense 1...{a}
  in the solution (Key 1.{K}!)."
---
set [A B]
key K [C A]
where K.threat_count <= 1,
  !(same_piece(a, b) && ((a.unguards(A) && b.unguards(A))
    || (a.opens_line() && b.opens_line()) || (A.slider
    && a.opens_line(WK) && b.opens_line(WK)) || (A.slider
    && !a.capture && !b.capture
    && collinear(a.from, a.to, b.to))))
story "Transferred mates: Set-play mate against defense
  1...{a} transfers to answer 1...{b} in the solution:
  2.{A}# (Key 1.{K}!{threat_clause})."
---
vir [A C]
+any K [B A]
where K.threat_count <= 1,
  !(same_piece(a, b) && (A.slider && !a.capture
    && !b.capture && collinear(a.from, a.to, b.to)))
with -no_threats_sparse_mates -no_threats_few_replies
  -match_threat_count
story "Transferred mates: Mate 2.{A}# transfers
  from {phase1} (1...{a}) to answer defense 1...{b}
  in {phase2}."
---
vir [A -]
+any K [B A]
where K.threat_count <= 1,
  !(same_piece(a, b) && ((a.unguards(A) && b.unguards(A))
    || (a.opens_line() && b.opens_line()) || (A.slider
    && a.opens_line(WK) && b.opens_line(WK)) || (A.slider
    && !a.capture && !b.capture
    && collinear(a.from, a.to, b.to))))
with -no_threats_sparse_mates -no_threats_few_replies
  -match_threat_count
story "Transferred mates: Mate 2.{A}# transfers
  from {phase1} (1...{a}) to answer defense 1...{b}
  in {phase2}."
---
vir [A B - -]
key [- - A B]
story "Transferred mates: Mates 2.{A}# and 2.{B}#
  transfer from virtual play to answer 1...{c} and 1...{d}
  in the solution (Key 1.{K}!{threat_clause})."
---
set [A B - -]
key (XY) [C* D* A B]
where A != C, B != D
with -match_threat_count -match_mate_count
story "Transferred mates: Set-play mates 2.{A}# and 2.{B}#
  against 1...{a} and 1...{b} transfer to answer 1...{c}
  and 1...{d} after Key 1.{K}!{threat_clause}."
---
set [A:P:= B:P:=]
key [C:P:= D:P:=]
where same_piece(A, B, C, D), A.promotion == D.promotion,
  B.promotion == C.promotion, A.promotion != B.promotion
with -match_mate_count
story "Transferred mates: Set-play promotion mates
  2.{A}# and 2.{B}# against 1...{a} and 1...{b}
  reciprocally transfer after Key 1.{K}!{threat_clause}:
  1...{a} 2.{C}# and 1...{b} 2.{D}#."
---
vir [A -]
+any K [- A]
where K.threat_count <= 1,
  !(same_piece(a, b) && ((a.unguards(A) && b.unguards(A))
    || (a.capture == b.capture && a.opens_line()
    && b.opens_line()) || (A.slider && a.opens_line(WK)
    && b.opens_line(WK)) || (A.slider && !a.capture
    && !b.capture && collinear(a.from, a.to, b.to))))
with -no_threats_sparse_mates -no_threats_few_replies
  -match_threat_count
story "Transferred mates: Mate 2.{A}# against 1...{a}
  in {phase1} transfers to answer defense 1...{b}
  in {phase2}."
---
set [A -]
key K [A* A]
where !same_piece(a, b), (a, b).role != 'K',
  K.threat_count <= 1, a.self_block, K.flights_given > 0
with -match_mate_count
subsumes MateTransference
story "Transferred mates: Set-play mate 2.{A}# against
  1...{a} transfers to also answer 1...{b} after
  Key 1.{K}!{threat_clause}."
```

### White combinations
**Enum**: `NamedTheme::WhiteCombinations`

Two or more White tries are individually refuted by distinct Black defenses a and b, which are answered by distinct checkmates in the key.

```thema
try Tr1 (X) [! _]
try Tr2 (Y*) [_ !]
key K (Z*) [A* B*]
where (X.to == Y.to && Y.to == Z.to) || (a.to == b.to
    && a.from != b.from)
with -match_threat_count -match_mate_count
  -refutation_is_check -single_refutation
  -capture_try_piece
story "White combinations: Tries 1.{Tr1}? (refuted
  by 1...{a}!) and 1.{Tr2}? (refuted by 1...{b}!)
  are resolved by Key 1.{K}!{threat_clause}:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
try Tr1 [! _]
try Tr2 [_ !]
key K [A* B*]
where K.threat_count == 0
with -match_threat_count -match_mate_count
  -refutation_is_check -single_refutation
  -capture_try_piece
story "White combinations: Tries 1.{Tr1}? (refuted
  by 1...{a}!) and 1.{Tr2}? (refuted by 1...{b}!) are
  resolved by waiting Key 1.{K}!: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Kubbel cycle
**Enum**: `NamedTheme::KubbelCycle` · *Alias*: Kubbel theme

Threefold circular square-to-square Umnov cycle across three variations: A.to == b.to, B.to == c.to, C.to == a.to.

```thema
key [A B C]
where A.to == b.to, B.to == c.to, C.to == a.to,
  distinct(A.to, B.to, C.to)
subsumes Stavrinides
story "Kubbel cycle: Threefold circular square-to-square
  Umnov cycle after Key 1.{K}!{threat_clause}:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, and 1...{c} 2.{C}#."
```

### Kharkov 2
**Enum**: `NamedTheme::Kharkov2` · *Alias*: Kharkov II

Chained refutations across tries: Try 1 is refuted by a!; Try 2 answers a with mate A but is refuted by b!; Try 3 answers a with mate B; Key answers both a and b with changed mates C and D.

```thema
try [! E]
try [A !]
try [B _]
key [C D]
with -match_threat_count -match_mate_count
  -capture_try_piece -refutation_is_check
subsumes ChangedMate
story "Kharkov 2: Chained refutation progression across
  Try 1.{Tr1}? (refuted by 1...{a}!), Try 1.{Tr2}?
  (1...{a} 2.{A}#, refuted by 1...{b}!), Try 1.{Tr3}?
  (1...{a} 2.{B}#), and Key 1.{K}!{threat_clause} (1...{a}
  2.{C}#, 1...{b} 2.{D}#)."
```

### Barnes analog for secondary threats
**Enum**: `NamedTheme::BarnesSecondary`

Dual defensive mates AB against a defense in one phase are reciprocally separated across two defenses in two subsequent phases.

```thema
try [AB _]
try [A B]
key [B A]
with -match_mate_count
subsumes ChangedPlay, TransferredMates
story "Barnes analog for secondary threats:
  Dual mates 2.{AB}# in Try 1.{Tr1}? are reciprocally
  separated across Try 1.{Tr2}? (1...{a} 2.{A}#,
  1...{b} 2.{B}#) and Key 1.{K}!{threat_clause} (1...{a}
  2.{B}#, 1...{b} 2.{A}#)."
```

### Karlstrøm-Fleck
**Enum**: `NamedTheme::KarlstromFleck` · *Alias*: Karlstrom-Fleck

Synthesis of Fleck and Karlstrøm themes: Key creates multiple threats while total defenses defeat all initial threats and force fresh non-threat checkmates A and B.

```thema
key (XY) [A B]
where (!A.recaptures(a) || !B.recaptures(b))
with -match_threat_count
subsumes DoubleThreat, Fleck
story "Karlstrøm-Fleck: Key 1.{K}! threatens multiple
  checkmates (2.{X}#, 2.{Y}#), while total defenses
  1...{a} and 1...{b} defeat all initial threats and force
  fresh checkmates 2.{A}# and 2.{B}#."
```

### Herpai
**Enum**: `NamedTheme::Herpai` · *Alias*: Herpai theme

Two Black defenses move to the same square: in Try 1, defense a allows mate A while defense b refutes; in Try 2, defense b allows mate B while defense a refutes; in Key, defenses a and b allow mates A and B.

```thema
try [A !]
try [! B]
key [A B]
where same_square(a, b), a.from != b.from
with -single_refutation -capture_try_piece -sparse_mates
  -few_replies -match_threat_count -match_mate_count
subsumes DefencesOnSameSquare, Laitinen
story "Herpai theme: Defenses 1...{a} and 1...{b}
  to {a.to} reciprocally allow and refute mates
  in Tries 1.{Tr1}? and 1.{Tr2}?, before uniting
  after Key 1.{K}!{threat_clause}: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Luukkonen
**Enum**: `NamedTheme::Luukkonen` · *Alias*: Luukkonen theme

Multiple Black defenses arriving on the same square receive the identical mate X in virtual play; in the key, X becomes the threat while those defenses receive distinct new mates A and B.

```thema
vir [X X]
key (X) [A B]
where same_square(a, b), a.from != b.from
with -match_threat_count
subsumes ChangedMate, DefencesOnSameSquare, Laitinen
story "Luukkonen: Defenses 1...{a} and 1...{b} to {a.to}
  both allowed 2.{X}# in {phase1}; Key 1.{K}! makes
  2.{X}# the threat and separates the defenses into
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Sushkov analog for secondary threats
**Enum**: `NamedTheme::SushkovSecondary`

Double threat AB in Try 1 is separated into secondary mates A and B in Tries 2 and 3 (refuted by b! and a!), and united in the Key against a and b.

```thema
try (AB) [_ _]
try [A !]
try [! B]
key [A B]
subsumes DoubleThreat, MoscowTheme, Rudenko
story "Sushkov analog for secondary threats:
  Double threat 2.{AB}# in Try 1.{Tr1}? is separated
  as variation mates in Tries 1.{Tr2}? and 1.{Tr3}?,
  and united after Key 1.{K}!{threat_clause}:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Shanshin dual avoidance
**Enum**: `NamedTheme::Shanshin` · *Alias*: Shanshin theme

Try threatens double threat AB and answers defense a with C; Key threatens DC and answers defense b with B.

```thema
try (AB) [C _]
key (DC) [_ B]
subsumes DoubleThreat, Isaev
story "Shanshin dual avoidance: Double threat 2.{AB}#
  and variation mate 2.{C}# in Try 1.{Tr}? reciprocally
  exchange places in Key 1.{K}! (double threat 2.{DC}#,
  variation 1...{b} 2.{B}#)."
```

### Block-to-threat change
**Enum**: `NamedTheme::BlockThreatChange`

Complete set-play block in the diagram position is disrupted by a threat-creating key that changes at least two set mates.

```thema
^set [A B]
^key (T) [C D]
where set_play_complete()
subsumes ChangedPlay, ThreatKey
story "Block-to-threat change: Complete set-play block
  (1...{a} 2.{A}#, 1...{b} 2.{B}#) is transformed
  by Threat Key 1.{K}! (threat 2.{T}#) into 1...{a} 2.{C}#
  and 1...{b} 2.{D}#."
```

### Threat-to-block key
**Enum**: `NamedTheme::ThreatToBlock`

A thematic try creates a threat, whereas the actual key is a waiting-move block that changes at least two mates.

```thema
^try (T) [A B]
^key K [C D]
where K.threat_count == 0
subsumes ChangedMate
story "Threat-to-block key: Threat Try 1.{Tr}?
  (threat 2.{T}#, 1...{a} 2.{A}#, 1...{b} 2.{B}#)
  yields to waiting-move Key 1.{K}! with changed mates
  1...{a} 2.{C}# and 1...{b} 2.{D}#."
```

### Double Threat Reversal
**Enum**: `NamedTheme::DoubleThreatReversal`

Try threatens double threat AB and answers defenses a and b with mate C; Key threatens C and answers defenses a and b with mates A and B.

```thema
try (AB) [C C _]
key (C) [A B _]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes LegrandDouble, ReciprocalZagoruiko, ShedeyCycle,
  TwinThreatChange
story "Double Threat Reversal: Try 1.{Tr}? threatens
  2.{A}# and 2.{B}# with 1...{a}/1...{b} 2.{C}#,
  reversed after Key 1.{K}! (threat 2.{C}#;
  1...{a} 2.{A}#, 1...{b} 2.{B}#)."
```

### Loshinsky magnet
**Enum**: `NamedTheme::LoshinskyMagnet` · *Alias*: Magnet theme

A White line-piece moves along a line in the key, drawing a Black line-piece along that same line to two distinct squares.

```thema
def [a:Q|R|B b:Q|R|B]
key K:Q|R|B [A B]
where same_piece(a, b), a.to != b.to,
  collinear(K.from, K.to, a.from),
  collinear(K.from, K.to, a.to),
  collinear(a.from, a.to, b.to)
story "Loshinsky magnet: White {K.role_name} key
  1.{K}!{threat_clause} draws Black's {a.role_name}
  on {a.from} along the line: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Kopaev theme
**Enum**: `NamedTheme::Kopaev` · *Alias*: Kopaev

A White try move 1.Tr? is refuted by a Black move landing on the try piece's vacated origin square, which is then answered by mate in the key.

```thema
def [a]
try Tr [! _]
key [A B]
where a.to == Tr.from
story "Kopaev theme: Try 1.{Tr}? vacates {Tr.from}
  and is refuted by 1...{a}! occupying {Tr.from};
  Key 1.{K}!{threat_clause} answers 1...{a} with 2.{A}#."
```

### Theme G
**Enum**: `NamedTheme::ThemeG` · *Alias*: Thema G

Two tries by a White pawn (one-step and two-step) fail to Black captures; the key captures with that pawn and turns those refutations into variations.

```thema
try Tr1:P (T) [! _]
try Tr2:P (T) [_ !]
key K:P:x (T) [A B]
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to)
subsumes CaptureKey, Isaev, SchneiderInterference
story "Theme G: Pawn tries 1.{Tr1}? (1...{a}!) and
  1.{Tr2}? (1...{b}!) are resolved by capture key 1.{K}!,
  yielding 2.{A}# and 2.{B}#."
```

### Guidelli
**Enum**: `NamedTheme::Guidelli` · *Alias*: Guidelli theme

White key moves a slider onto a line; moves of a Black Queen or slider along that line allow both recapture mates and a repeat mate by the key piece.

```thema
def [a:Q|R|B b:Q|R|B c:Q|R|B]
key K:Q|R|B [A B A]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  A.from == K.to, B.to == b.to
story "Guidelli: Key 1.{K}!{threat_clause}.
  Moves of the Black {a.role} (1...{a}, 1...{b},
  1...{c}) allow 2.{A}# and capture mate 2.{B}#."
```

### Brogi
**Enum**: `NamedTheme::Brogi` · *Alias*: Brogi theme

Two tries by the same White piece threaten single mates and are refuted by the same Black defense; the key by that piece threatens both mates (and more) simultaneously.

```thema
try Tr1 (A) [!]
try Tr2 (B) [!]
key K (AB) [C]
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes DoubleThreat, WhiteCorrection
story "Brogi: Tries 1.{Tr1}? (threat 2.{A}#) and 1.{Tr2}?
  (threat 2.{B}#) fail to 1...{a}!; Key 1.{K}! threatens
  both 2.{A}# and 2.{B}# and answers 1...{a} with 2.{C}#."
```

### Dentist theme
**Enum**: `NamedTheme::Dentist`

The White key piece moves to provoke a Black slider check and then mates by capturing the checking slider (and also mates after another move of that slider).

```thema
def [a:R|B|Q:+ b:R|B|Q]
key K [A:x@a B]
where same_piece(a, b), A.from == K.to, B.from == K.to
subsumes ProvokedCheck
story "Dentist theme: Key 1.{K}!{threat_clause} provokes
  1...{a} (answered by capture 2.{A}#) and 1...{b}
  (answered by 2.{B}#) with the key piece."
```

### Crimean theme
**Enum**: `NamedTheme::Crimean`

Three tries Tr1, Tr2, Tr3 by the same White piece are refuted by three different Black pieces capturing on the same square (defenses a, b, c); Key K moves that White piece so captures a, b, c allow mates A, B, C.

```thema
def [a:x b:x c:x]
try Tr1 [! _ _]
try Tr2 [_ ! _]
try Tr3 [_ _ !]
key K [A B C]
where same_piece(Tr1, Tr2, Tr3, K), same_square(a, b, c),
  distinct(a.from, b.from, c.from)
subsumes MoscowTheme, MultipleCaptures, WhiteCorrection
story "Crimean theme: Tries 1.{Tr1}?, 1.{Tr2}?, and
  1.{Tr3}? fail to captures on {a.to} (1...{a}!, 1...{b}!,
  1...{c}!); Key 1.{K}! answers them with 2.{A}#, 2.{B}#,
  and 2.{C}#."
```

### Zhuravlev theme
**Enum**: `NamedTheme::Zhuravlev` · *Alias*: Zhuravlev combination

In Phase 1, White plays 1.C? with double threat (2.A#, 2.B#); in Phase 2, White plays 1.B! threatening 2.C# with variation mate 1...a 2.A#.

```thema
try C (AB)
+any B (C) [A]
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
  -refutation_is_check
story "Zhuravlev theme: Try 1.{C}? (threats 2.{A}#,
  2.{B}#) reverses into 1.{B} (threat 2.{C}#;
  1...{a} 2.{A}#)."
---
try A (B) [_]
try B (C) [A]
key K (A) [B]
where distinct(A, B, K)
with -match_threat_count
story "Zhuravlev theme: Moves {A} and {B} cycle across
  Try 1.{A}? (threat 2.{B}#), Try 1.{B}? (1...{a} 2.{A}#),
  and Key 1.{K}! (threat 2.{A}#; 1...{a} 2.{B}#)."
```

### Papack cycle
**Enum**: `NamedTheme::PapackCycle`

Three White moves A, B, C cycle between double-threat components and variation mate across a try and the key: Try threatens (AB) with 1...a 2.C#; Key threatens (BC) with 1...a 2.A#.

```thema
try (AB) [C]
key (BC) [A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedMate, DoubleThreat
story "Papack cycle: Try 1.{Tr}? (threats 2.{A}#, 2.{B}#;
  1...{a} 2.{C}#) cycles into Key 1.{K}! (threats 2.{B}#,
  2.{C}#; 1...{a} 2.{A}#)."
```

### One-line Herpai
**Enum**: `NamedTheme::OneLineHerpai`

Two Black pieces moving to the same square force mates A and B in set play (with dual avoidance) and changed mates C and D after the key.

```thema
vir [A B]
key K [C D]
where same_square(a, b), a.from != b.from,
  (K.threat_count > 0 || (!between(a.from, C.from, C.to)
    && !between(b.from, D.from, D.to)))
subsumes ChangedPlay, DefencesOnSameSquare, Laitinen
story "One-line Herpai: On {a.to}, defenses 1...{a}
  and 1...{b} change from virtual mates 2.{A}#/2.{B}#
  to 2.{C}#/2.{D}# after Key 1.{K}!."
```

### Zarur theme
**Enum**: `NamedTheme::Zarur` · *Alias*: Zarur

Virtual play has mates A and B after defenses a and b; tries Tr1 (mates C on a, refuted by b) and Tr2 (refuted by a, mates D on b) by the same White piece each change one mate; Key K changes both to E and F.

```thema
vir [A B]
try Tr1 [C !]
try Tr2 [! D]
key K [E F]
where same_piece(Tr1, Tr2)
subsumes ChangedPlay, Makrava
story "Zarur theme: Set play (2.{A}#, 2.{B}#),
  Tries 1.{Tr1}? (1...{a} 2.{C}#; 1...{b}!) and
  1.{Tr2}? (1...{b} 2.{D}#; 1...{a}!), and Key 1.{K}!
  (2.{E}#, 2.{F}#)."
```

### Fokin
**Enum**: `NamedTheme::Fokin` · *Alias*: Fokin theme

Three tries Tr1, Tr2, Tr3 (threatening T) to square K.to are refuted by Black defenses a, b, c to the same square; Key K (threatening T) answers a, b, c with mates A, B, C by those three try pieces.

```thema
try Tr1 (T) [! _ _]
try Tr2 (T) [_ ! _]
try Tr3 (T) [_ _ !]
key K (T) [A B C]
where same(Tr1.to, Tr2.to, Tr3.to, K.to),
  same(a.to, b.to, c.to), same_piece(Tr1, A),
  same_piece(Tr2, B), same_piece(Tr3, C)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes DefencesOnSameSquare, PlayOnSameSquare
story "Fokin: Three tries 1.{Tr1}?, 1.{Tr2}?, 1.{Tr3}?
  to {K.to} fail to defenses 1...{a}!, 1...{b}!, 1...{c}!
  on {a.to}; Key 1.{K}! answers them with mates 2.{A}#,
  2.{B}#, 2.{C}# by those three try pieces."
```

### Neva theme
**Enum**: `NamedTheme::Neva` · *Alias*: Neva

Three tries threaten mates A, B, C (all refuted by defense r); in the Key, captures a, b, c by the same Black piece on three distinct squares allow mates A, B, C.

```thema
def [r a:x b:x c:x]
try (A) [! _ _ _]
try (B) [! _ _ _]
try (C) [! _ _ _]
key [_ A B C]
where same_piece(a, b, c), distinct(a.to, b.to, c.to)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "Neva theme: Three tries with threats 2.{A}#,
  2.{B}#, 2.{C}# (all refuted by 1...{r}!) lead
  to Key 1.{K}!, where captures 1...{a}, 1...{b}, 1...{c}
  by the same Black piece allow 2.{A}#, 2.{B}#, 2.{C}#."
```

### Munich theme
**Enum**: `NamedTheme::Munich` · *Alias*: Munich

Three tries by the same White slider with the same threat are each refuted by a different Black piece (R, B, N); the key by that slider solves.

```thema
try Tr1 (T) [! _ _]
try Tr2 (T) [_ ! _]
try Tr3 (T) [_ _ !]
key K (T) [A B C]
where same_piece(Tr1, Tr2, Tr3, K), K.slider,
  distinct(a.from, b.from, c.from)
subsumes Isaev, ThreatKey, WhiteCorrection
story "Munich theme: Slider tries 1.{Tr1}? (1...{a}!),
  1.{Tr2}? (1...{b}!), and 1.{Tr3}? (1...{c}!) with threat
  2.{T}# are solved by 1.{K}!."
```

### Kontrawechsel
**Enum**: `NamedTheme::Kontrawechsel`

Two tries are refuted by the one-step and two-step advances of the same Black pawn; the key threatens two mates and answers those pawn advances with mates on the same square.

```thema
def [a:P b:P]
try Tr1 [! _]
try Tr2 [_ !]
key K (XY) [A B]
where same_piece(a, b), a.to != b.to, A.from != B.from,
  A.to == B.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Barulin, KarlstromFleck
story "Kontrawechsel: Tries 1.{Tr1}? (1...{a}!)
  and 1.{Tr2}? (1...{b}!) are solved by Key 1.{K}!
  (threats 2.{X}#, 2.{Y}#), answering 1...{a} 2.{A}# and
  1...{b} 2.{B}# on {A.to}."
```

### Adabashev synthesis
**Enum**: `NamedTheme::Adabashev`

Two tries by the same White piece share a primary threat A while introducing secondary threats B and C (refuted by a and b); the key reverses or unites those moves.

```thema
try Tr1 (AB) [! _]
try Tr2 (AC) [_ !]
key [B C]
where same_piece(Tr1, Tr2)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes DoubleThreat
story "Adabashev synthesis: Double-threat tries 1.{Tr1}?
  (2.{A}#, 2.{B}#; 1...{a}!) and 1.{Tr2}? (2.{A}#, 2.{C}#;
  1...{b}!) are united in Key 1.{K}!: 1...{a} 2.{B}# and
  1...{b} 2.{C}#."
```

### Bogdanov-Rychkov
**Enum**: `NamedTheme::BogdanovRychkov`

Tries Tr1 (threatening XYZ, refuted by a) and Tr2 (threatening XY, refuted by b) and Key K (threatening X) by the same White piece progressively reduce the threats, with Key K answering defenses a and b with Z and Y.

```thema
try Tr1 (XYZ) [! _]
try Tr2 (XY) [_ !]
key K (X) [Z Y]
where same_piece(Tr1, Tr2, K)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes DoubleThreat
story "Bogdanov-Rychkov: Progressive threat reduction
  by 1.{Tr1}? (threats 2.{X}#, 2.{Y}#, 2.{Z}#; 1...{a}!),
  1.{Tr2}? (threats 2.{X}#, 2.{Y}#; 1...{b}!), and Key
  1.{K}! (threat 2.{X}#; 1...{a} 2.{Z}#, 1...{b} 2.{Y}#)."
```

### Burkhardt mate
**Enum**: `NamedTheme::BurkhardtMate` · *Alias*: Burkhardt

The key threatens at least four mates by the same White Rook or Bishop moving along its orthogonal/diagonal rays, separated by Black defenses.

```thema
key (ABCD) [A:R|B B:R|B C:R|B D:R|B]
where same_piece(A, B, C, D),
  distinct(A.to, B.to, C.to, D.to)
with -match_threat_count
subsumes BatteryMate, BatteryPlay, KarlstromFleck
story "Burkhardt mate: Key 1.{K}! threatens four
  {A.role} mates (2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#),
  separated by 1...{a}, 1...{b}, 1...{c}, and 1...{d}."
```

### Total Fleck
**Enum**: `NamedTheme::TotalFleck`

The key threatens three distinct mates, and three moves by the same Black defender individually force each of the three threats as the unique checkmate.

```thema
key (ABC) [A B C]
where same_piece(a, b, c), distinct(a.to, b.to, c.to)
with -match_threat_count
subsumes DoubleThreat, Fleck
story "Total Fleck: Key 1.{K}! threatens 2.{A}#, 2.{B}#,
  and 2.{C}#; moves of a single Black {a.role} (1...{a},
  1...{b}, 1...{c}) force each threat in turn."
```

### Seneca theme
**Enum**: `NamedTheme::Seneca` · *Alias*: Gosman-Seneca

Three checking tries A, B, C by the same White piece are refuted by three Black King flights a, b, c; after Key K, Black defenses d, e, f to those same squares (a.to, b.to, c.to) allow A, B, C as variation mates.

```thema
def [a:K b:K c:K d e f]
try A:+ [! _ _ _ _ _]
try B:+ [_ ! _ _ _ _]
try C:+ [_ _ ! _ _ _]
key K [_ _ _ A B C]
where same_piece(A, B, C), distinct(A.to, B.to, C.to),
  a.to == d.to, b.to == e.to, c.to == f.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes WhiteCorrection
story "Seneca theme (Gosman-Seneca): Checking tries 1.{A}?
  (1...{a}!), 1.{B}? (1...{b}!), and 1.{C}? (1...{c}!)
  become mates 2.{A}#, 2.{B}#, 2.{C}# after 1...{d},
  1...{e}, 1...{f} following Key 1.{K}!."
```

### Fastosky theme
**Enum**: `NamedTheme::Fastosky` · *Alias*: Fastosky

In virtual play, two Black sliders capturing on the same square (defenses a and b) allow mates A and B; the Key changes the mates after captures a and b to C and D and adds Black King capture c on that same square allowing mate E.

```thema
def [a:R|B:x b:R|B:x c:K:x]
vir [A B _]
key [C D E]
where same_square(a, b, c), a.from != b.from
subsumes FlightCapture, MultipleCaptures, OneLineHerpai,
  SomovA
story "Fastosky theme: Set captures 1...{a} 2.{A}#
  and 1...{b} 2.{B}# on {a.to} change after Key 1.{K}!
  to 2.{C}# and 2.{D}#, with added King capture
  1...{c} 2.{E}#."
```

### Kubbel chain
**Enum**: `NamedTheme::KubbelChain`

Three tries by the same White slider along a line are refuted by a Black slider following it step-by-step onto the vacated or adjacent squares along that line (Loshinsky magnet chain).

```thema
try Tr1 [! _ _]
try Tr2 [_ ! _]
try Tr3 [_ _ !]
key K [A _ _]
where same_piece(Tr1, Tr2, Tr3, K), K.slider,
  same_piece(a, b, c), a.slider, a.to == Tr1.from,
  b.to == Tr1.to, c.to == Tr2.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes LoshinskyMagnet
story "Kubbel chain: White slider tries 1.{Tr1}?,
  1.{Tr2}?, 1.{Tr3}? are shadowed step-by-step by
  1...{a}!, 1...{b}!, 1...{c}! before Key 1.{K}! solves."
```

### Kubbel theme
**Enum**: `NamedTheme::KubbelTheme`

Two tries A and B by the same White piece are reciprocally refuted by defenses a and b landing on each other's destination squares (A.to == b.to, B.to == a.to); Key K answers defenses a and b with mates A and B.

```thema
try A [! _]
try B [_ !]
key K [A B]
where same_piece(A, B), A.to == b.to, B.to == a.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "Kubbel theme: White tries 1.{A}? and 1.{B}? are
  reciprocally refuted by Black moves 1...{a}! (to {B.to})
  and 1...{b}! (to {A.to}), then become variation mates
  after Key 1.{K}!."
```

### Larsen Task
**Enum**: `NamedTheme::LarsenTask` · *Alias*: Baltic theme

A sacrificial key is captured on its arrival square by three distinct Black pieces, and all three resulting checkmates are delivered on the exact same square by three different White moves.

```thema
def [a:x@K b:x@K c:x@K]
key K [A B C]
where distinct(a.from, b.from, c.from),
  same_square(A, B, C)
subsumes TripleSacrificeKey
story "Larsen Task (Baltic theme): Key 1.{K}! sacrifices
  on {K.to}; captures 1...{a}, 1...{b}, and 1...{c} are
  answered on the same square {A.to} by 2.{A}#, 2.{B}#,
  and 2.{C}#."
```

### Nesic theme
**Enum**: `NamedTheme::Nesic` · *Alias*: Nesic

Two tries Tr1 and Tr2 by different White pieces to the same square fail to defenses a and b; a third White piece moves to that same square as Key K and changes the virtual mates A and B after a and b to C and D.

```thema
vir [A B]
try Tr1 [! _]
try Tr2 [_ !]
key K [C D]
where same_square(Tr1, Tr2, K),
  distinct(Tr1.from, Tr2.from, K.from)
subsumes ChangedPlay, Sushkov
story "Nesic theme: Three White pieces occupy {K.to}—Tries
  1.{Tr1}? (1...{a}!) and 1.{Tr2}? (1...{b}!) fail, while
  Key 1.{K}! changes set play (2.{A}#, 2.{B}#) to 2.{C}#
  and 2.{D}#."
```

### Ellerman-Mäkihovi
**Enum**: `NamedTheme::EllermanMakihovi`

Set-play dual mate AB against defense a is separated into mate A in a try (refuted by defense b) and mate B in the Key.

```thema
set [AB _]
try [A !]
key [B _]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedMate
story "Ellerman-Mäkihovi: Set-play dual
  1...{a} 2.{A}#/2.{B}# is separated into 1...{a} 2.{A}#
  after Try 1.{Tr}? (refuted by 1...{b}!) and
  1...{a} 2.{B}# after Key 1.{K}!."
```

### Anti-Moscow theme
**Enum**: `NamedTheme::AntiMoscow`

Two tries with different threats are refuted by two Black defenses that open and close lines (Moscow defenses as try refutations), which are answered in the key.

```thema
try (X) [! _]
try (Y) [_ !]
key (Z) [A B]
where a.opens_line(), b.opens_line(),
  (a.closes_line() || a.self_block),
  (b.closes_line() || b.self_block)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes MoscowTheme, ThreatKey
story "Anti-Moscow theme: Tries 1.{Tr1}? (threat 2.{X}#;
  1...{a}!) and 1.{Tr2}? (threat 2.{Y}#; 1...{b}!) fail to
  line-opening/closing defenses, overcome by Key 1.{K}!."
```

### Reciprocal Kopaev
**Enum**: `NamedTheme::KopaevReciprocal`

Across two phases, two Black defenses that open and close lines reciprocally exchange their allowed mates.

```thema
vir [A B]
key [B A]
where (a.opens_line() || b.opens_line()),
  (a.closes_line() || b.closes_line())
subsumes LineClosure, ReciprocalChange, SelfInterference
story "Reciprocal Kopaev: Line-opening/closing defenses
  1...{a} and 1...{b} reciprocally exchange mates 2.{A}#
  and 2.{B}# after Key 1.{K}!."
```

### Volgograd double
**Enum**: `NamedTheme::VolgogradDouble`

Try 1.A? threatens BC and answers defense a with mate D (refuted by b); Key 1.B! threatens AD and answers defense a with mate C (doubled Volgograd).

```thema
try A (BC) [D !]
key B (AD) [C _]
where distinct(A, B, C, D)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay, ThreatKey
story "Volgograd double: Try 1.{A}? (threats 2.{B}#,
  2.{C}#; 1...{a} 2.{D}#) and Key 1.{B}! (threats 2.{A}#,
  2.{D}#; 1...{a} 2.{C}#) exchange first moves, threats,
  and mates."
```

---

## 06. Phase Changes, Transferences & Changed Play

*Changes of checkmate against the same defense across phases (Zagoruiko, Rukhlis, Bikos, Reciprocal Change, Transferred Mates, Mutate).*

### Albino
**Enum**: `NamedTheme::Albino`

A White Pawn on its initial square (rank 2) executes all 4 possible pawn moves across mating variations, threats, or phases.

```thema
any [A:P B:P C:P D:P]
where pawn_quartet(A, B, C, D)
with -match_mate_count
story "Albino: Key 1.{K}!{threat_clause} The White
  pawn on {A.from} charts all four compass directions
  to deliver checkmate: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#"
---
any (A:P) [B:P C:P D:P]
where pawn_quartet(A, B, C, D)
with -match_mate_count
story "Albino: The White pawn on {A.from} charts all four
  compass directions across threat 2.{A}# and variations
  2.{B}#, 2.{C}#, 2.{D}#"
---
any A:P
any B:P
any C:P
any D:P
where pawn_quartet(A, B, C, D)
with -single_refutation -sparse_mates -few_replies
  -capture_try_piece -match_threat_count
story "Albino: The White pawn on {A.from} executes
  all four compass moves across phases: 1.{A}, 1.{B},
  1.{C}, 1.{D}"
---
try [A:P _ _ _]
try [_ B:P _ _]
try [_ _ C:P _]
key [_ _ _ D:P]
where pawn_quartet(A, B, C, D)
with -match_mate_count
story "Albino: The White pawn on {A.from} charts
  all four compass directions across tries and key:
  2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#"
```

### Stocchi
**Enum**: `NamedTheme::Stocchi` · *Alias*: Stocchi correction

Three or more Black defenses close the same square (self-block), or cross-correction/multi-phase Stocchi blocks.

```thema
any [A B C]
where same_square(a, b, c),
  distinct(a.from, b.from, c.from), (a, b, c).role != 'K',
  (a, b, c).flight_block,
  (a.self_block || b.self_block || c.self_block
    || (a.capture && b.capture && c.capture))
story "Stocchi blocks: Key 1.{K}!{threat_clause}.
  Three Black defenses close {a.to}, each met
  by a distinct checkmate: 1...{a} 2.{A}#, 1...{b} 2.{B}#,
  1...{c} 2.{C}#."
---
key K [A A B B B]
where A != B, same_piece(a, b, c), same_piece(d, e),
  (a, d).role != 'K',
  (a.from != d.from || (collinear(a.from, a.to, b.to)
    && collinear(a.from, a.to, c.to)
    && collinear(d.from, d.to, e.to)
    && !collinear(a.from, a.to, d.to))),
  !(K.threat_count == 0 && guards(c.from, A.to)
    && guards(c.to, A.to))
story "Stocchi correction: Key 1.{K}!{threat_clause}.
  The defense 1...{c} (correction for the {a.piece}
  on {a.from}, general mate 2.{A}#) allows 2.{B}#,
  which also serves as the general mate for the {d.piece}
  on {d.from}."
---
key K [A A AB B B]
where same_piece(a, b, c), same_piece(d, e),
  (a, d).role != 'K', a.from != d.from,
  !(K.threat_count == 0 && guards(c.from, A.to)
    && guards(c.to, A.to))
story "Stocchi correction: Key 1.{K}!{threat_clause}.
  The defense 1...{c} (correction for the {a.piece}
  on {a.from}, general mate 2.{A}#) allows 2.{B}#,
  which also serves as the general mate for the {d.piece}
  on {d.from}."
---
vir [A]
try [B]
key [C]
where a.self_block
story "Stocchi: Self-block defense 1...{a} on {a.to} is
  answered by three distinct checkmates across phases:
  2.{A}#, 2.{B}#, and 2.{C}# after key
  1.{K}!{threat_clause}."
```

### Reversal
**Enum**: `NamedTheme::Reversal` · *Alias*: Reciprocal Change

Reciprocal change of mates (A, B vs B, A) across two phases against defenses a and b, or functional reversal between phase move and mate (Try A mates B; Key B mates A).

```thema
vir [A B]
+any [B A]
with -no_threats_sparse_mates -no_threats_few_replies
  -match_threat_count
subsumes ChangedMate, TransferredMates
story "Reversal: Reciprocal changed play between {phase1}
  (1...{a} 2.{A}# vs 1...{b} 2.{B}#) and {phase2} (1...{a}
  2.{B}# vs 1...{b} 2.{A}#)."
---
try A [B]
+any B [A]
with -no_threats_sparse_mates -no_threats_few_replies
  -match_threat_count -capture_try_piece
  -single_refutation
story "Reversal: Functional reversal between Try 1.{A}?
  (1...{a} 2.{B}#) and 1.{B}! (1...{a} 2.{A}#)."
```

### Threat Reversal
**Enum**: `NamedTheme::ThreatReversal`

Reciprocal change between phase move and threat across two phases: Try A threatens B; Key B threatens A.

```thema
try A (B)
+any B (A)
with -capture_try_piece
subsumes ThreatAntiReversal
story "Threat Reversal: Reciprocal exchange between
  threat and key moves across two phases: Try 1.{A}?
  (threat 2.{B}#) and Key 1.{B}! (threat 2.{A}#)."
```

### Zagoruiko
**Enum**: `NamedTheme::Zagoruiko` · *Alias*: Zagoruiko 3x2

Changed checkmates across 3 phases against defenses a and b (3x2: A, B / C, D / E, F).

```thema
^vir [A B]
^try [C D]
^key [E F]
where count_distinct(A, B, C, D, E, F) >= 5
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay
story "Zagoruiko (3×2): Three distinct phases produce
  changed mates against defenses 1...{a} and 1...{b}:
  {phase1} (2.{A}# / 2.{B}#), Try 1.{Tr}? (2.{C}#
  / 2.{D}#), and Key 1.{K}!{threat_clause} (2.{E}#
  / 2.{F}#)."
```

### Zagoruiko 3x3
**Enum**: `NamedTheme::Zagoruiko3x3`

Changed checkmates across 3 phases against defenses a, b, c (3x3: A, B, C / D, E, F / G, H, I).

```thema
^vir [A B C]
^try [D E F]
^key [G H I]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ThreeChangedMates, Zagoruiko
story "Zagoruiko (3×3): Three distinct phases produce
  three trios of changed mates against defenses 1...{a},
  1...{b}, and 1...{c}: {phase1}, Try 1.{Tr}?,
  and Key 1.{K}!{threat_clause}."
```

### Rukhlis
**Enum**: `NamedTheme::Rukhlis`

Mates against defenses a and b change in a subsequent phase to C and D, while original mates A and B reappear against new defenses c and d.

```thema
vir [A B _ _]
+any [C D A B]
with -match_threat_count -capture_try_piece
  -single_refutation -no_threats_few_replies
  -no_threats_sparse_mates
story "Rukhlis: Key 1.{K}!{threat_clause}. Mates
  against 1...{a} (2.{A}#) and 1...{b} (2.{B}#) transfer
  to 1...{c} and 1...{d}, while fresh mates answer the
  original defenses: 1...{a} 2.{C}# and 1...{b} 2.{D}#."
---
vir [A B _]
+any [C D A]
where distinct(A, B, C, D)
with -match_threat_count -capture_try_piece
  -single_refutation -no_threats_few_replies
  -no_threats_sparse_mates
story "Rukhlis: Mates against 1...{a} (2.{A}#) and 1...{b}
  (2.{B}#) change to 2.{C}# and 2.{D}# while 2.{A}#
  transfers to 1...{c}."
---
vir [A B _]
+any (A) [C D B]
with -match_threat_count -capture_try_piece
  -single_refutation -no_threats_few_replies
  -no_threats_sparse_mates
story "Rukhlis: Mates against 1...{a} (2.{A}#) and 1...{b}
  (2.{B}#) change to 2.{C}# and 2.{D}# while 2.{A}#
  becomes the threat and 2.{B}# transfers to 1...{c}."
---
vir [A B _]
+any (A) [- C B]
with -match_threat_count -capture_try_piece
  -single_refutation -no_threats_few_replies
  -no_threats_sparse_mates
subsumes ChangedMate
story "Rukhlis: Mates against 1...{a} (2.{A}#) and 1...{b}
  (2.{B}#) shift as 2.{A}# becomes the threat, 1...{b}
  receives changed mate 2.{C}#, and 2.{B}# transfers
  to 1...{c}."
```

### Twente
**Enum**: `NamedTheme::Twente`

Dual separation across phases: dual mates AB in one phase separated into distinct mates A and B in another phase.

```thema
vir [AB AB]
key [A B]
with -single_refutation -refutation_is_check
  -capture_try_piece -sparse_mates -few_replies
  -match_threat_count
subsumes ChangedMate, TransferredMates
story "Twente: Dual mates 2.{AB}# in {phase1}
  are separated into distinct checkmates after
  key 1.{K}!{threat_clause}: 1...{a} 2.{A}#
  vs 1...{b} 2.{B}#."
```

### Changed Mate
**Enum**: `NamedTheme::ChangedMate`

Simple mate change (A to B) against defense a across two phases.

```thema
set [A]
key [B]
with -match_mate_count
story "Changed mate: Defense 1...{a} is met by checkmate
  2.{A}# in set play, changed to 2.{B}# after key
  1.{K}!{threat_clause}."
---
try [A]
key [B]
with -match_mate_count -capture_try_piece
  -refutation_is_check
story "Changed mate: Defense 1...{a} is met by checkmate
  2.{A}# in try 1.{Tr}?, changed to 2.{B}# after key
  1.{K}!{threat_clause}."
---
vir [A]
try [B]
with -match_mate_count -capture_try_piece
  -refutation_is_check
story "Changed mate: Defense 1...{a} receives changed
  checkmates between {phase1} (2.{A}#) and try 1.{Tr}?
  (2.{B}#)."
```

### Anti-Reversal
**Enum**: `NamedTheme::AntiReversal`

Anti-reversal changed play across tries and key (e.g., Try A mates B, Try B mates C, Key C mates A against defense a).

```thema
try A [B]
try B [C]
key C [A]
story "Anti-reversal: Cyclic changed play
  across three phases (Try 1.{A}?, Try 1.{B}?,
  Key 1.{C}!{threat_clause}) parries reciprocal reversal."
---
try A [B]
key K (B) [A]
with -refutation_is_check
story "Anti-reversal: Try 1.{A}? answers defense 1...{a}
  with 2.{B}#; Key 1.{K}! threatens 2.{B}# and answers
  1...{a} with 2.{A}#."
---
try A [B]
key C [A]
where distinct(A, B, C)
story "Anti-reversal: Try 1.{A}? answers 1...{a} with
  2.{B}#; Key 1.{C}!{threat_clause} answers 1...{a}
  with 2.{A}#."
---
try A [B]
key B [C]
where distinct(A, B, C)
subsumes ChangedMate
story "Anti-reversal: Try 1.{A}? answers 1...{a} with
  2.{B}#; Key 1.{B}!{threat_clause} answers 1...{a}
  with 2.{C}#."
```

### Threat Anti-Reversal
**Enum**: `NamedTheme::ThreatAntiReversal`

Try move T appears as threat T in another phase K, or threat K of try T becomes phase move K.

```thema
try T
+any K (T)
where K.threat_count <= 2
with -match_threat_count -single_refutation
  -capture_try_piece
story "Threat anti-reversal: Try move 1.{T}? returns as
  the threat 2.{T}# after 1.{K}."
---
try T (K)
+any K
where T.threat_count <= 2
with -match_threat_count -single_refutation
  -capture_try_piece
story "Threat anti-reversal: Threat 2.{K}# of try 1.{T}?
  becomes the first move 1.{K}!."
```

### Zagoruiko 4x2
**Enum**: `NamedTheme::Zagoruiko4x2`

Changed checkmates across 4 phases against defenses a and b (4x2: A, B / C, D / E, F / G, H).

```thema
^vir [A B]
^try [C D]
^try [E F]
^key [G H]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Zagoruiko
story "Zagoruiko (4×2): Four distinct phases produce four
  pairs of changed mates against defenses 1...{a} and
  1...{b}, culminating in key 1.{K}!{threat_clause}."
```

### Zagoruiko 4x3
**Enum**: `NamedTheme::Zagoruiko4x3`

Changed checkmates across 4 phases against defenses a, b, c (4x3: A, B, C / D, E, F / G, H, I / J, M, L).

```thema
^vir [A B C]
^try [D E F]
^try [G H I]
^key [J M L]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Zagoruiko3x3, Zagoruiko4x2
story "Zagoruiko (4×3): Four distinct phases weave
  changed mates against three defenses 1...{a}, 1...{b},
  and 1...{c}, culminating in key 1.{K}!{threat_clause}."
```

### Zagoruiko Nanning
**Enum**: `NamedTheme::ZagoruikoNanning`

Nanning variation of the Zagoruiko theme across three phases against defenses a and b (A, B / B, C / D, A).

```thema
vir [A B]
try [B C]
key [D A]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Brabec3
story "Zagoruiko Nanning: Changed play across phases
  combined with Nanning dual avoidance, resolved by key
  1.{K}!{threat_clause}."
```

### Threat Zagoruiko 3x2
**Enum**: `NamedTheme::ThreatZago3x2`

Zagoruiko changed play combining threats (A, B, C) and defensive mates (D, E, F) against defense a across 3 phases.

```thema
try (A) [D]
try (B) [E]
key (C) [F]
subsumes ChangedPlay, ThreatKey
story "Threat Zagoruiko 3×2: Three phases feature
  changed threats combined with changed defensive mates:
  Try 1.{Tr1}?, Try 1.{Tr2}?, and Key 1.{K}!
  (threat 2.{C}#, defense 1...{a} 2.{F}#)."
```

### Threat Zagoruiko 4x2
**Enum**: `NamedTheme::ThreatZago4x2`

Zagoruiko changed play combining threats (A, C, E, G) and defensive mates (B, D, F, H) against defense a across 4 phases.

```thema
try (A) [B]
try (C) [D]
try (E) [F]
key (G) [H]
subsumes ThreatZago3x2
story "Threat Zagoruiko 4×2: Four phases feature
  changed threats combined with changed defensive mates,
  culminating in key 1.{K}! (threat 2.{G}#, defense
  1...{a} 2.{H}#)."
```

### Zagoruiko Distributed
**Enum**: `NamedTheme::ZagoruikoDist`

Distributed Zagoruiko changed play across phases: Try 1 (A, B), Try 2 (C, -), Try 3 (-, D), and Key (E, F) against defenses a and b.

```thema
try [A B]
try [C -]
try [- D]
key [E F]
subsumes ChangedPlay
story "Zagoruiko Distributed: Changed mates distributed
  across tries 1.{Tr1}?, 1.{Tr2}?, 1.{Tr3}?, and key
  1.{K}!{threat_clause} (1...{a} 2.{E}#, 1...{b} 2.{F}#)."
```

### Urania
**Enum**: `NamedTheme::Urania`

Urania theme: move A appears across three phases as first move A, threat A (after phase move T), and variation mate A against defense a.

```thema
any A
any T (A)
any [A]
where T.threat_count <= 2
with -capture_try_piece -match_threat_count
  -match_mate_count -no_threats_few_replies
  -no_threats_sparse_mates -refutation_is_check
  -flight_from_check -single_refutation
story "Urania: Move {A} functions across three phases as
  a first move, a threat, and a variation checkmate."
```

### Bartolović
**Enum**: `NamedTheme::Bartolovic` · *Alias*: Bartolovic

Bartolović theme: changed play across three phases against defenses a and b: Try 1 (A, B), Try 2 (C, B), and Key (A, D).

```thema
try [A B]
try [C B]
key [A D]
subsumes ChangedPlay
story "Bartolović: Reciprocal changed play across tries
  1.{Tr1}?, 1.{Tr2}?, and key 1.{K}!{threat_clause}:
  1...{a} 2.{A}#, 1...{b} 2.{D}#."
```

### Rukhlis Condensed
**Enum**: `NamedTheme::RukhlisCondensed`

Condensed Rukhlis mate transference: Try answers defenses a, b with mates A, B; Key answers defenses a, b, c with mates C, A, B.

```thema
try [A B]
key [C A B]
subsumes ChangedMate, TransferredMates
story "Rukhlis Condensed: Try 1.{Tr}? and key
  1.{K}!{threat_clause} exhibit compact mate transference:
  mate 2.{A}# against 1...{a} transfers to 1...{b},
  while a fresh mate 2.{C}# answers 1...{a}."
```

### Rukhlis Distributed
**Enum**: `NamedTheme::RukhlisDistributed`

Distributed Rukhlis transference across three phases and four defenses a, b, c, d: virtual play (A, B, _, _), Try (C, _, A, _), and Key (_, D, _, B).

```thema
vir [A B _ _]
try [C _ A _]
key [_ D _ B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Brabec1, Rukhlis, TransferredMates
story "Rukhlis Distributed: Distributed mate
  transference across {phase1}, try 1.{Tr}?, and key
  1.{K}!{threat_clause}: 1...{a} 2.{C}#, 1...{b} 2.{D}#."
```

### Ideal Rukhlis
**Enum**: `NamedTheme::IdealRuklis`

Ideal Rukhlis across four defenses a, b, c, d: Try answers a, b, c, d with A, B, C, D; Key answers a, b, c, d with E, F, A, B.

```thema
try [A B C D]
key [E F A B]
subsumes FourChangedMates, Rukhlis, TransferredMates
story "Ideal Rukhlis: Complete six-mate
  transference matrix between try 1.{Tr}? and key
  1.{K}!{threat_clause}: 1...{a} 2.{E}#, 1...{b} 2.{F}#,
  1...{c} 2.{A}#, 1...{d} 2.{B}#."
```

### Extended Rukhlis
**Enum**: `NamedTheme::ExtendedRuklis`

Extended Rukhlis transference: virtual mates A, B, C against defenses a, b, c change in the Key to D, E, F while A, B, C transfer to defenses d, e, f.

```thema
vir [A B C _ _ _]
key [D E F A B C]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay, Rukhlis, ThreeChangedMates
story "Extended Rukhlis: Extended mate transference
  spanning multiple defenses between {phase1} and key
  1.{K}!{threat_clause}."
```

### Rukhlis Parti Sur 3 Phases A
**Enum**: `NamedTheme::RukhlisPartiSur3PhasesA`

Rukhlis divided across 3 phases (variant A) over defenses a, b, c, d: virtual play (A, B, -, -), Try (C, D, -, -), and Key (-, -, A, B).

```thema
vir [A B - -]
try [C D - -]
key [- - A B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedPlay, Sushkov, TransferredMates
story "Rukhlis (3 Phases A): Rukhlis mate transference
  partitioned across {phase1}, try 1.{Tr}?, and key
  1.{K}!{threat_clause}."
```

### Rukhlis Parti Sur 3 Phases B
**Enum**: `NamedTheme::RukhlisPartiSur3PhasesB`

Rukhlis divided across 3 phases (variant B) over defenses a, b, c, d: virtual play (A, B, _, _), Try (C, _, A, _), and Key (_, D, _, B).

```thema
vir [A B _ _]
try [C _ A _]
key [_ D _ B]
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes Brabec1, Rukhlis, TransferredMates
story "Rukhlis (3 Phases B): Rukhlis mate transference
  partitioned across {phase1}, try 1.{Tr}?, and key
  1.{K}!{threat_clause}."
```

### Reciprocal Change
**Enum**: `NamedTheme::ReciprocalChange`

Reciprocal change of mates between virtual play (1...a 2.A#, 1...b 2.B#) and the Key (1...a 2.B#, 1...b 2.A#).

```thema
vir [A B]
key [B A]
subsumes Reversal
story "Reciprocal Change: Checkmates against
  defenses 1...{a} (2.{A}#) and 1...{b} (2.{B}#)
  in virtual play are reciprocally swapped after
  key 1.{K}!{threat_clause}: 1...{a} 2.{B}#
  vs 1...{b} 2.{A}#."
```

### Chepizhny
**Enum**: `NamedTheme::Chepizhny`

Chepizhny theme: recurring mate D shifts across defenses b, c, d alongside changed mates A, B, C on defense a across Try 1, Try 2, and the Key.

```thema
try [A D _ _]
try [B _ D _]
key [C _ _ D]
subsumes ChangedPlay
story "Chepizhny: Recurring mate 2.{D}# alongside changed
  mates 2.{A}#, 2.{B}#, 2.{C}# across tries 1.{Tr1}?,
  1.{Tr2}?, and key 1.{K}!{threat_clause}."
```

### Bikos
**Enum**: `NamedTheme::Bikos` · *Alias*: Bikos theme

Reciprocal change of harmful defense effects: defense a produces self-block in one phase and unguard/exposure to capture in another phase, while defense b reciprocally produces unguard/exposure to capture and self-block.

```thema
vir [A B]
+any [C D]
where A != C, B != D, (a, b).flight_block,
  (A.recaptures(a) && !B.recaptures(b) && !C.recaptures(a)
    && D.recaptures(b)) || (!A.recaptures(a)
    && B.recaptures(b) && C.recaptures(a)
    && !D.recaptures(b))
subsumes ChangedMate
story "Bikos: Reciprocal change of harmful defense effects
  (self-block vs exposure to capture) between {phase1} and
  {phase2} across 1...{a} (2.{A}# -> 2.{C}#) and 1...{b}
  (2.{B}# -> 2.{D}#)."
```

### Java
**Enum**: `NamedTheme::Java` · *Alias*: Java theme

Two Black defenses each close one of two White guard lines to a flight square, forcing dual avoidance between two mates by the same White piece.

```thema
key [A B]
where same_piece(A, B), A.to != B.to, a.unpins(A),
  b.unpins(B), (a.closes_line(WK) || a.cuts_enemy_line()),
  (b.closes_line(WK) || b.cuts_enemy_line())
story "Java theme: Key 1.{K}!{threat_clause}.
  Dual self-blocks 1...{a} and 1...{b} uniquely unlock
  checkmates 2.{A}# and 2.{B}#."
---
def [a:!x b:!x]
key [A B]
where K.threat_count > 0, same_piece(a, b), a.to != b.to,
  same_piece(A, B), A.to != B.to, !A.recaptures(a),
  !B.recaptures(b),
  (a.closes_line(WK) || a.cuts_enemy_line()),
  (b.closes_line(WK) || b.cuts_enemy_line())
story "Java theme: Key 1.{K}!{threat_clause}.
  Defenses 1...{a} and 1...{b} close White guard lines,
  forcing dual avoidance between 2.{A}# and 2.{B}#."
```

### Haring
**Enum**: `NamedTheme::Haring` · *Alias*: Haring theme

In at least two phases, the White move following the same Black defense is a switchback of the key-piece.

```thema
try Tr [A~Tr]
key K  [B~K]
where Tr.threat_count > 0 || K.threat_count > 0
    || Tr.from != K.from
with -match_threat_count
subsumes ChangedMate
story "Haring: In two phases, White's reply to 1...{a}
  is a switchback of the key piece (Try 1.{Tr}? and Key
  1.{K}!{threat_clause}), delivering 2.{A}# and 2.{B}#."
```

### Makrava
**Enum**: `NamedTheme::Makrava`

Try 1 refuted by a (answers b with mate A); Try 2 refuted by b (answers a with the same mate A); Key answers both with changed mates C and D.

```thema
try [! A]
try [A !]
key [C D]
subsumes ChangedMate
story "Makrava: Tries 1.{Tr1}? (1...{a}!, 1...{b} 2.{A}#)
  and 1.{Tr2}? (1...{a} 2.{A}#, 1...{b}!) transfer
  mate 2.{A}# before Key 1.{K}!{threat_clause} delivers
  1...{a} 2.{C}# and 1...{b} 2.{D}#."
```

### Added play
**Enum**: `NamedTheme::AddedPlay`

A defense exists in post-key play that had no checkmate provided in set play.

```thema
set [-]
key K [A]
where K.threat_count == 0 || set_play_complete()
story "Added play: Key 1.{K}!{threat_clause} introduces
  new mating variations not present in set play:
  1...{a} 2.{A}#."
```

### Removed play
**Enum**: `NamedTheme::RemovedPlay`

A defense provided with mate in set play has no variation in post-key play.

```thema
set [A]
key K [-]
where K.threat_count == 0 || A.from != K.from
    || a.role == 'K'
with -match_mate_count
story "Removed play: Key 1.{K}!{threat_clause} eliminates
  the set-play variation 1...{a} 2.{A}#, focusing White's
  attack on the solution."
---
key K
where has_removed_set_defense(),
  (K.threat_count <= 1 || set_mate_count() > 1)
story "Removed play: Key 1.{K}!{threat_clause} eliminates
  a set-play variation, focusing White's attack
  on the solution."
```

### Changed play
**Enum**: `NamedTheme::ChangedPlay`

The same Black defense receives different checkmates across phases.

```thema
set [A]
key [B]
story "Changed play: Key 1.{K}!{threat_clause} changes
  the mating reply against 1...{a} from set mate 2.{A}#
  to 2.{B}#."
---
try [A B]
key [C D]
with -single_refutation -capture_try_piece
  -refutation_is_check -sparse_mates -few_replies
story "Changed play: Key 1.{K}!{threat_clause} changes
  the mating replies against 1...{a} and 1...{b} from
  2.{A}#, 2.{B}# to 2.{C}#, 2.{D}#."
```

### Progressive
**Enum**: `NamedTheme::Progressive`

Progressive increase or intensification of thematic motives across phases.

```thema
def [a:+ b c d]
key [A B C D]
where b.pins(BK), c.unpins(WK), d.self_block, d.was_flight
subsumes ProvokedCheck, SelfBlock, SelfPin
story "Progressive: Key 1.{K}!{threat_clause}
  progressively unlocks mates across varied defenses:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#,
  1...{d} 2.{D}#."
```

### Visserman
**Enum**: `NamedTheme::Visserman`

Changed mates between set play (A, B) and the Key (C, D) against two Black King flights a and b.

```thema
def [a:K b:K]
set [A B]
key [C D]
subsumes FreeChange, KingFlight
story "Visserman: Fourfold changed play across phases:
  1...{a} set 2.{A}# / key 2.{C}#, 1...{b} set 2.{B}# /
  key 2.{D}# (Key 1.{K}!{threat_clause})."
```

### Free change
**Enum**: `NamedTheme::FreeChange`

Changed checkmates between set play and actual play for two or more defenses.

```thema
set [A B]
key [C D]
where A != C, B != D
subsumes ChangedPlay
story "Free change: Key 1.{K}!{threat_clause} changes
  checkmates between phases without try threats:
  1...{a} set 2.{A}# / key 2.{C}#, 1...{b} set 2.{B}# /
  key 2.{D}#."
```

### Check - Non-check
**Enum**: `NamedTheme::CheckNonCheck`

Thematic contrast between checking and non-checking moves across phases.

```thema
try [A B]
key K:K [B* A*]
where a.is_check != b.is_check
with -match_mate_count
subsumes ChangedMate
story "Check - Non-check: Thematic contrast between
  checking and non-checking Black defenses across
  Try 1.{Tr}? and Royal Key 1.{K}!{threat_clause}:
  1...{a} and 1...{b}."
```

### Salazar
**Enum**: `NamedTheme::Salazar` · *Alias*: Salazar theme

Reversal of White's first and second moves across try and key against the same Black defense (Try 1.A? 1...a 2.B#; Key 1.B! 1...a 2.A#).

```thema
try A [B]
+any B [A]
with -match_threat_count -match_mate_count -few_replies
  -sparse_mates -single_refutation -capture_try_piece
  -refutation_is_check
subsumes ChangedMate
story "Salazar: Reversal of White's first and second moves
  against defense 1...{a}: Try 1.{A}? answers 1...{a} with
  2.{B}#, while 1.{B} answers 1...{a} with 2.{A}#."
```

### Salazar (double)
**Enum**: `NamedTheme::SalazarDouble` · *Alias*: Double Salazar

Double Salazar reversal: two tries 1.A? and 1.B? answer defenses with 2.C#, and Key 1.C! answers those defenses with 2.A# and 2.B#.

```thema
try A [C _]
try B [_ C]
key C [A B]
subsumes BatteryMate, BatteryPlay, Salazar, VladimirovCC2
story "Double Salazar: Tries 1.{A}? (1...{a} 2.{C}#)
  and 1.{B}? (1...{b} 2.{C}#) reverse first and second
  moves with Key 1.{C}!{threat_clause} (1...{a} 2.{A}#,
  1...{b} 2.{B}#)."
```

### Black correction in Try
**Enum**: `NamedTheme::BlackCorrectionTry`

Black correction play occurring in a virtual try phase.

```thema
def [r a]
try (T) [T A]
where a.corrects(r)
story "Black correction in Try: In Try 1.{Tr}?
  (threat 2.{T}#), random move 1...{r} allows 2.{T}#,
  while correction 1...{a} forces 2.{A}#."
```

### Black correction in set play
**Enum**: `NamedTheme::BlackCorrectionSetPlay`

Black piece executes a random move and a correction move in set play, with changed mates in the key.

```thema
def [r1 r2 a]
set [A A B]
key [C C D]
where same_piece(r1, r2, a), r1.to < r2.to,
  distinct(r1.to, r2.to, a.to), !(r1, r2, a).check,
  !B.recaptures(a)
subsumes FreeChange
story "Black correction in set play: Set play features
  random defense 1...{r1} 2.{A}# and correction
  1...{a} 2.{B}#, changed after Key 1.{K}!{threat_clause}
  to 1...{r1} 2.{C}# and 1...{a} 2.{D}#."
```

### Double Black correction
**Enum**: `NamedTheme::DoubleBlackCorrection`

Two distinct Black pieces each execute a random move and a specific correction move in the key phase.

```thema
def [r1 a r2 b]
key (T) [T A T B]
where a.corrects(r1), b.corrects(r2), diff_piece(a, b)
subsumes ThreatKey
story "Double Black correction: Key 1.{K}! (threat 2.{T}#)
  provokes corrections from two Black pieces:
  1...{r1} 2.{T}# / 1...{a} 2.{A}# and 1...{r2} 2.{T}# /
  1...{b} 2.{B}#."
```

### Reciprocal cross-checks
**Enum**: `NamedTheme::ReciprocalCrossCheck`

Two Black checking defenses have their cross-check mates reciprocally exchanged between virtual play and actual play.

```thema
def [a:+ b:+]
vir [A B]
+any [B A]
subsumes ChangedCrossCheck, ChangedPlay, CrossCheck,
  ProvokedCheck, Reversal
story "Reciprocal cross-checks: Black checks 1...{a} and
  1...{b} reciprocally swap cross-check mates 2.{A}# and
  2.{B}# between {phase1} and {phase2}."
```

### Reciprocal Zagoruiko
**Enum**: `NamedTheme::ReciprocalZagoruiko`

Three-phase Zagoruiko over two defenses where two phases reciprocally exchange mates (A, B vs B, A) and the third phase introduces changed mates (C, D).

```thema
^vir [A B]
^vir [B A]
^key [C D]
subsumes ChangedPlay, Reversal
story "Reciprocal Zagoruiko: Defenses 1...{a} and
  1...{b} reciprocally swap 2.{A}# and 2.{B}# in virtual
  play, then change to 2.{C}# and 2.{D}# after
  Key 1.{K}!{threat_clause}."
```

### Three changed mates
**Enum**: `NamedTheme::ThreeChangedMates`

At least three Black defenses receive changed mates between virtual play (set or try) and the key.

```thema
^vir [A B C]
^key [D E F]
subsumes ChangedMate
story "Three changed mates: Mates after 1...{a},
  1...{b}, and 1...{c} change from 2.{A}#, 2.{B}#,
  2.{C}# in {phase1} to 2.{D}#, 2.{E}#, 2.{F}# after
  Key 1.{K}!{threat_clause}."
```

### Four changed mates
**Enum**: `NamedTheme::FourChangedMates`

At least four Black defenses receive changed mates between virtual play and the key.

```thema
^vir [A B C D]
^key [E F G H]
subsumes ChangedPlay, ThreeChangedMates
story "Four changed mates: Mates after 1...{a}, 1...{b},
  1...{c}, and 1...{d} all change from {phase1} (2.{A}#,
  2.{B}#, 2.{C}#, 2.{D}#) to Key 1.{K}!{threat_clause}
  (2.{E}#, 2.{F}#, 2.{G}#, 2.{H}#)."
```

### Changed Star-flights
**Enum**: `NamedTheme::ChangedStarFlights`

All four diagonal star-flights of the Black King receive changed mates between virtual play and the key.

```thema
def [a:K b:K c:K d:K]
^vir [A B C D]
^key [E F G H]
where (a, b, c, d).diag, distinct(a.to, b.to, c.to, d.to)
subsumes FourChangedMates, RadialFlights, StarFlights
story "Changed Star-flights: All four diagonal Black King
  flights (1...{a}, 1...{b}, 1...{c}, 1...{d}) receive
  changed mates after Key 1.{K}!{threat_clause}."
```

### Changed Cross-flights
**Enum**: `NamedTheme::ChangedCrossFlights`

All four orthogonal cross-flights of the Black King receive changed mates between virtual play and the key, or two orthogonal flights in set-play are replaced by the other two orthogonal flights after the key.

```thema
def [a:K b:K c:K d:K]
^vir [A B C D]
^key [E F G H]
where (a, b, c, d).ortho, distinct(a.to, b.to, c.to, d.to)
subsumes BkTShapeFlights, FourChangedMates, RadialFlights
story "Changed Cross-flights: All four orthogonal Black
  King flights (1...{a}, 1...{b}, 1...{c}, 1...{d})
  receive changed mates after Key 1.{K}!{threat_clause}."
---
def [a:K b:K c:K d:K]
vir [A B _ _]
key [_ _ C D]
where (a, b, c, d).ortho, distinct(a.to, b.to, c.to, d.to)
subsumes ChangedPlay, FlightGivingAndTakingKey
story "Changed Cross-flights: Orthogonal Black King
  flights 1...{a} (2.{A}#) and 1...{b} (2.{B}#)
  in {phase1} are replaced by the orthogonal flights
  1...{c} (2.{C}#) and 1...{d} (2.{D}#) after
  Key 1.{K}!{threat_clause}."
```

### Twin-threat Zagoruiko
**Enum**: `NamedTheme::TwinThreatChange`

Three phases each feature a distinct threat (X, Y, Z) and changed mates across two Black defenses.

```thema
^vir (X) [A B]
^try (Y) [C D]
^key (Z) [E F]
subsumes ChangedPlay, ThreatKey
story "Twin-threat Zagoruiko: Three phases with distinct
  threats (2.{X}#, 2.{Y}#, 2.{Z}#) and 3x2 changed mates
  across 1...{a} and 1...{b}."
```

### Double Albino
**Enum**: `NamedTheme::DoubleAlbino`

Two distinct White Pawns on the 2nd rank each execute all four Albino moves, or an Albino quartet occurs in two phases.

```thema
vir [A:P B:P C:P D:P _ _ _ _]
+any [_ _ _ _ E:P F:P G:P H:P]
where pawn_quartet(A, B, C, D), pawn_quartet(E, F, G, H)
story "Double Albino: Two White Pawn quartets occur across
  {phase1} (2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#) and {phase2}
  (2.{E}#, 2.{F}#, 2.{G}#, 2.{H}#)."
```

### Double Pickaninny
**Enum**: `NamedTheme::DoublePickaninny`

A Black Pawn on the 7th rank executes all four Pickaninny moves with changed mates between virtual play and actual play.

```thema
def [a:P b:P c:P d:P]
^vir [A B C D]
^key [E F G H]
where pawn_quartet(a, b, c, d)
subsumes FourChangedMates, Pickaninny
story "Double Pickaninny: Black Pawn on {a.from} executes
  its four-move Pickaninny with changed mates between
  {phase1} (2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#) and Key 1.{K}!
  (2.{E}#, 2.{F}#, 2.{G}#, 2.{H}#)."
```

### Focal self-block
**Enum**: `NamedTheme::FocalSelfBlock`

Two different Black pieces self-block on two different flight squares while reciprocally allowing mate on each other's blocking square.

```thema
def [a b]
key [A@b B@a]
where diff_piece(a, b), a.to != b.to, (a, b).self_block
subsumes SelfBlock
story "Focal self-block: After Key 1.{K}!{threat_clause},
  Black self-blocks 1...{a} and 1...{b} reciprocally
  concede checkmates on each other's squares:
  2.{A}# and 2.{B}#."
```

### Theme F
**Enum**: `NamedTheme::ThemeF` · *Alias*: Thema F

Two tries Tr1 and Tr2 by a White piece (threatening T) are reciprocally refuted by a Black piece's moves a and b (Tr1.to == b.to, Tr2.to == a.to); Key K moves that White piece to a third square and answers a and b with mates A and B.

```thema
try Tr1 (T) [! _]
try Tr2 (T) [_ !]
key K (T) [A B]
where same_piece(Tr1, Tr2, K), same_piece(a, b),
  Tr1.to == b.to, Tr2.to == a.to,
  distinct(Tr1.to, Tr2.to, K.to)
subsumes Isaev, ThreatKey, WhiteCorrection
story "Theme F: Tries 1.{Tr1}? and 1.{Tr2}? are
  reciprocally refuted by 1...{a}! and 1...{b}!;
  Key 1.{K}! answers them with 2.{A}# and 2.{B}#."
```

### Zappas
**Enum**: `NamedTheme::Zappas` · *Alias*: Zappas theme

At least three phases (tries and key) feature the same mate A after defense a in tries (each refuted by a different defense b, c) before changing or resolving in the key.

```thema
try [A ! _]
try [A _ !]
key [A B C]
story "Zappas: Tries 1.{Tr1}? (1...{b}!) and 1.{Tr2}?
  (1...{c}!) share 1...{a} 2.{A}#; Key 1.{K}! resolves all
  three with 2.{A}#, 2.{B}#, and 2.{C}#."
```

### Zappas simple
**Enum**: `NamedTheme::ZappasSimple`

Against two Black defenses on the same square, two tries and the key produce three completely changed pairs of mates (3x2 Zagoruiko on the same defense square).

```thema
try [A B]
try [C D]
key [E F]
where same_square(a, b), a.from != b.from
subsumes OneLineHerpai, Zagoruiko
story "Zappas simple: On square {a.to} (1...{a}, 1...{b}),
  Try 1.{Tr1}? (2.{A}#, 2.{B}#), Try 1.{Tr2}? (2.{C}#,
  2.{D}#), and Key 1.{K}! (2.{E}#, 2.{F}#) produce three
  pairs of mates."
```

### Spisska-Borovicka
**Enum**: `NamedTheme::SpisskaBorovicka`

Total four-move reciprocal exchange between a try and the key: Try 1.A? (2.B#) answers 1...a 2.C#, 1...b 2.D#; Key 1.C! (2.D#) answers 1...a 2.B#, 1...b 2.A#.

```thema
try A (B) [C D]
key C (D) [B A]
subsumes AntiReversal, DombrovskisCrossClosed2,
  PseudoErokhin, PseudoSalazar, VladimirovCC2
story "Spisska-Borovicka: Try 1.{A}? (threat 2.{B}#;
  1...{a} 2.{C}#, 1...{b} 2.{D}#) reciprocally exchanges
  all four moves with Key 1.{C}! (threat 2.{D}#;
  1...{a} 2.{B}#, 1...{b} 2.{A}#)."
```

### Anti-Salazar
**Enum**: `NamedTheme::AntiSalazar`

Two tries reciprocally exchange first move and threat (1.A? threat 2.B# and 1.B? threat 2.A#), both refuted by the same defense, while the key solves with a third move.

```thema
try A (B) [!]
try B (A) [!]
key K [C]
where distinct(A, B, K)
with -match_threat_count -capture_try_piece
subsumes ThreatAntiReversal
story "Anti-Salazar: Tries 1.{A}? (threat 2.{B}#)
  and 1.{B}? (threat 2.A#) both fail to 1...{a}!,
  solved by Key 1.{K}! (1...{a} 2.{C}#)."
```

### Pseudo Salazar
**Enum**: `NamedTheme::PseudoSalazar`

Two phases exchange first move and variation mate across different Black defenses (1.A? 1...a 2.B# and 1.B 1...b 2.A#), or two tries exchange first move and mate against the same defense.

```thema
try A [B _]
+any B [_ A]
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
  -refutation_is_check
story "Pseudo Salazar: Try 1.{A}? (1...{a} 2.{B}#) and
  1.{B} (1...{b} 2.{A}#) exchange first move and mate
  across different Black defenses."
---
try A [B]
try B [A]
key K [C]
story "Pseudo Salazar: Tries 1.{A}? (1...{a} 2.{B}#) and
  1.{B}? (1...{a} 2.{A}#) exchange first move and mate,
  followed by Key 1.{K}! (1...{a} 2.{C}#)."
```

### Dalton
**Enum**: `NamedTheme::Dalton` · *Alias*: Dalton theme

Set play has Black correction by one Black piece allowing mates A and B; the key pins that piece so a second Black piece executes correction allowing the same mates A and B.

```thema
vir [A B _ _]
key [_ _ A B]
where same_piece(a, b), same_piece(c, d), a.from != c.from
story "Dalton: Set correction by {a.piece_desc} (1...{a}
  2.{A}#, 1...{b} 2.{B}#) transfers after Key 1.{K}!
  to {c.piece_desc} (1...{c} 2.{A}#, 1...{d} 2.{B}#)."
```

### Arnstam theme
**Enum**: `NamedTheme::Arnstam` · *Alias*: Arnstam

In a White correction try, two Black pieces capturing on the same square allow the same mate A (passive dual avoidance); in the key, those captures force two distinct changed mates B and C.

```thema
def [a:x b:x]
try Tr [A A]
key K [B C]
where same_piece(Tr, K), same_square(a, b),
  a.from != b.from
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ChangedMate, DefencesOnSameSquare, Laitinen
story "Arnstam theme: In Try 1.{Tr}?, captures 1...{a} and
  1...{b} on {a.to} both allow 2.{A}#; after Key 1.{K}!,
  they separate into 2.{B}# and 2.{C}#."
```

### Gooderson
**Enum**: `NamedTheme::Gooderson` · *Alias*: Gooderson theme

In virtual play, two Black defenses a and b to the same square allow mates A and B; after the Key, defenses a and b allow changed mates C and D while other moves c and d of those same two pieces allow the original mates A and B (Rukhlis + Black correction).

```thema
vir [A B _ _]
key [C D A B]
where same_square(a, b), a.from != b.from,
  same_piece(a, c), same_piece(b, d)
subsumes OneLineHerpai, Rukhlis
story "Gooderson: Set mates 2.{A}# and 2.{B}# after
  captures 1...{a} and 1...{b} on {a.to} change to 2.{C}#
  and 2.{D}# after Key 1.{K}!, while reappearing after
  random moves 1...{c} and 1...{d}."
```

### Freie Presse theme
**Enum**: `NamedTheme::FreiePresse`

Set play has two checking moves A and B as mates against defenses a and b; tries 1.A+? and 1.B+? are refuted by Black King flights c and d; the key changes the mates after a and b while transferring A# and B# to new Black defenses e and f.

```thema
vir [A B _ _ _ _]
try A:+ [_ _ ! _ _ _]
try B:+ [_ _ _ ! _ _]
key K [!A !B _ _ A B]
where (c, d).role == 'K'
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "Freie Presse theme: Set mates 2.{A}# (after
  1...{a}) and 2.{B}# (after 1...{b}) fail as checking
  tries 1.{A}? (1...{c}!) and 1.{B}? (1...{d}!);
  Key 1.{K}!{threat_clause} changes the mates after
  1...{a} and 1...{b} while transferring 2.{A}# and 2.{B}#
  to 1...{e} and 1...{f}."
```

### Muleblock theme
**Enum**: `NamedTheme::Muleblock` · *Alias*: Muleblock

In set play, defense a allows quiet mate A (self-block) and defense b allows capture mate B; after the key, defense a is captured by C while defense b self-blocks to allow quiet mate A (Bikos + transferred mate).

```thema
vir [A!@a B@b]
key [C@a A!@b]
where a.self_block || b.self_block
subsumes ChangedMate, TransferredMates
story "Muleblock theme: Set play (1...{a} 2.{A}#
  self-block, 1...{b} 2.{B}# capture) switches after
  Key 1.{K}! to 1...{a} 2.{C}# capture and 1...{b} 2.{A}#
  transferred self-block."
```

### Røpke
**Enum**: `NamedTheme::Ropke` · *Alias*: Roepke theme

Two Black pawns each promote to a Queen and a Knight, and the four promotions are answered by distinct or reciprocal White mates.

```thema
def [a:P:=Q b:P:=N c:P:=Q d:P:=N]
key [A B C D]
where same_piece(a, b), same_piece(c, d), a.from != c.from
subsumes BlackUnderpromotion
story "Røpke: Key 1.{K}!{threat_clause}. Dual promotions
  by two Black pawns (1...{a} 2.{A}#, 1...{b} 2.{B}# and
  1...{c} 2.{C}#, 1...{d} 2.{D}#) produce distinct mates."
---
def [a:P:= b:P:= c:P:= d:P:=]
key [A B B A]
where same_piece(a, b), same_piece(c, d),
  a.from != c.from, a.promotion != b.promotion,
  c.promotion != d.promotion
subsumes BlackUnderpromotion
story "Røpke: Key 1.{K}!{threat_clause}.
  Dual promotions by two Black pawns (1...{a} 2.{A}#,
  1...{b} 2.{B}# and 1...{c} 2.{B}#, 1...{d} 2.{A}#)
  produce reciprocal mates."
```

### Breton Adverse
**Enum**: `NamedTheme::BretonAdverse`

Reciprocal change of mates (A, B to B, A) between virtual play and the Key where two different White pieces swap mates against two Black capture defenses a and b.

```thema
def [a:x b:x]
vir [A B]
key [B A]
where A.from != B.from
subsumes ReciprocalChange
story "Breton Adverse: Captures 1...{a} and 1...{b}
  reciprocally exchange mates 2.{A}# and 2.{B}# between
  virtual play and Key 1.{K}!."
```

### Urania doubled
**Enum**: `NamedTheme::UraniaDoubled`

Two distinct White moves A and B both appear across three phases as first move, threat, and variation mate.

```thema
try A (B) [_ _]
try B (A) [_ _]
key K [A B]
where distinct(A, B, K)
with -match_threat_count -capture_try_piece
subsumes ThreatAntiReversal, Urania
story "Urania doubled: Both {A} and {B} appear as try
  first move, try threat, and variation mate after
  Key 1.{K}! (1...{a} 2.{A}#, 1...{b} 2.{B}#)."
```

---

## 07. Black & White Corrections

*Random moves by defending or attacking units yielding general flaws, corrected by specific moves with secondary flaws (Somov, Stocchi).*

### White correction
**Enum**: `NamedTheme::WhiteCorrection`

White tries make general moves with a piece which are refuted; the key makes a corrected move with the same piece.

```thema
try Tr1 (X) [!]
try Tr2 (X) [_]
key K [A]
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to),
  Tr1.threat_count == Tr2.threat_count,
  Tr1.threat_count <= 2,
  (K.threat_count > 0 || K.opens_line(WK))
with -match_threat_count -match_mate_count
story "White correction: Random White tries 1.{Tr1}? and
  1.{Tr2}? fail; thematic correction 1.{K}!{threat_clause}
  succeeds with 2.{A}# against 1...{a}."
---
try Tr1 [!]
try Tr2 [_]
key K [A]
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to),
  (Tr1.threat_count == 0 || Tr2.threat_count == 0),
  Tr1.threat_count <= 2, Tr2.threat_count <= 2,
  (K.threat_count > 0 || K.opens_line(WK))
with -match_threat_count -match_mate_count
story "White correction: Random White tries 1.{Tr1}? and
  1.{Tr2}? fail; thematic correction 1.{K}!{threat_clause}
  succeeds with 2.{A}# against 1...{a}."
---
try Tr1 [! _]
try Tr2 [_ !]
key K
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to), Tr1.threat_count == 0,
  Tr2.threat_count == 0,
  (K.threat_count > 0 || K.opens_line(WK))
with -match_threat_count -match_mate_count
  -single_refutation -capture_try_piece
story "White correction: White tries 1.{Tr1}? and 1.{Tr2}?
  by the same piece fail to 1...{a}! and 1...{b}!;
  correction 1.{K}!{threat_clause} succeeds."
---
try Tr1 (X) [! _]
try Tr2 (X) [_ !]
key K
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to),
  Tr1.threat_count == Tr2.threat_count,
  Tr1.threat_count <= 2,
  (K.threat_count > 0 || K.opens_line(WK))
with -match_threat_count -match_mate_count
  -single_refutation -capture_try_piece
story "White correction: White tries 1.{Tr1}? and 1.{Tr2}?
  by the same piece fail to 1...{a}! and 1...{b}!;
  correction 1.{K}!{threat_clause} succeeds."
---
try Tr1 (X) [! _]
try Tr2 (Y) [_ !]
key K [A B]
where same_piece(Tr1, Tr2), Tr1.to != Tr2.to,
  Tr1.threat_count <= 2, Tr2.threat_count <= 2,
  (K.opens_line(WK) || Tr1.opens_line(WK)
    || X.to == Tr1.from || X == Y)
with -match_threat_count -match_mate_count
  -single_refutation
story "White correction: White tries 1.{Tr1}? and 1.{Tr2}?
  by the same piece fail to 1...{a}! and 1...{b}!;
  Key 1.{K}!{threat_clause} succeeds."
---
try Tr (X) [!]
+any K (Y) [A]
where same_piece(Tr, K), Tr.to != K.to,
  (Tr.opens_line(WK) || K.opens_line(WK)
    || X.to == Tr.from || K.to == X.to),
  (X.from != Tr.to || Tr.opens_line(WK)),
  (X.from != Y.from || X.to != Y.to)
with -match_threat_count -match_mate_count
story "White correction: White try 1.{Tr}? (threat 2.{X}#)
  fails to 1...{a}!; correction 1.{K}! (threat 2.{Y}#)
  answers 1...{a} with 2.{A}#."
---
try Tr (X) [!]
key K (X) [A]
where same_piece(Tr, K), Tr.to != K.to,
  (Tr.opens_line(WK) || K.opens_line(WK)
    || X.to == K.from)
story "White correction: White try 1.{Tr}? fails
  to 1...{a}!; thematic correction 1.{K}!{threat_clause}
  succeeds with 2.{A}#."
```

### Somov
**Enum**: `NamedTheme::Somov` · *Alias*: Somov theme

Black correction defense unguards a square allowing a distinct mate.

```thema
key K [A A B]
where A != B, same_piece(a, b, c),
  distinct(a.to, b.to, c.to),
  (c.to != B.to || c.pinned_to(WK) || c.pinned_to(BK)),
  c.unguards(B),
  !(guards(a.to, B.to) && guards(b.to, B.to)),
  !(K.threat_count == 0 && guards(c.from, A.to)
    && guards(c.to, A.to)),
  !(K.threat_count == 0 && between(c.from, A.from, A.to)
    && collinear(A.from, c.from, c.to)),
  !(a, b).check
story "Somov: Key 1.{K}!{threat_clause}. Random moves
  allow general mate 2.{A}#, but correction defense
  1...{c} unguards {B.to}, allowing checkmate 2.{B}#."
```

### Black correction
**Enum**: `NamedTheme::BlackCorrection`

A general Black piece move allows the threat or a general mate; Black corrects with the same piece to parry it, forcing a new mate or refuting a try.

```thema
def [a:N|B|R|Q b]
key K (T) [A B]
where same_piece(a, b), a.to != b.to,
  ((!A.recaptures(a) && !B.recaptures(b))
    || (T.to == a.from && (!A.recaptures(a)
    || !B.recaptures(b)) && A.from != B.from)),
  (a.role == 'N' || (!a.capture || !b.capture))
story "Black correction: Key 1.{K}! threatens 2.{T}#.
  A general defense allows the threat, while corrected
  defenses 1...{a} and 1...{b} parry it but allow 2.{A}#
  and 2.{B}#."
---
def [a:N|B|R|Q b c]
key K [A A B]
where A != B, same_piece(a, b, c),
  distinct(a.to, b.to, c.to), a.to != A.to, b.to != A.to,
  !(c.capture && B.recaptures(c)),
  !(K.threat_count == 0 && !c.capture
    && guards(c.from, A.to) && guards(c.to, A.to)),
  !(K.threat_count == 0 && between(c.from, A.from, A.to)
    && collinear(A.from, c.from, c.to))
story "Black correction: Key 1.{K}!{threat_clause}.
  General moves 1...{a} and 1...{b} allow mate 2.{A}#,
  while corrected defense 1...{c} allows distinct
  mate 2.{B}#."
---
def [a:N|B|R|Q b]
try [A !]
try [! B]
where same_piece(a, b), a.to != b.to, !a.capture,
  !b.capture, A.to != a.to, B.to != b.to
story "Black correction: Correction defenses 1...{a} and
  1...{b} by the same Black piece reciprocally allow mates
  2.{A}#, 2.{B}# and refute tries 1.{Tr1}?, 1.{Tr2}?."
---
def [a:N|B|R|Q b c]
try [A A !]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  a.to != A.to, b.to != A.to, !c.capture
story "Black correction: In try 1.{Tr}?, general moves
  1...{a} and 1...{b} allow 2.{A}# while corrected defense
  1...{c}! refutes."
---
def [a:N|B|R|Q b c]
key K [A A A]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  a.to != A.to, b.to != A.to, c.to == A.to, !c.check,
  !(K.threat_count == 0 && c.slider)
story "Black correction: Key 1.{K}!{threat_clause}.
  Random moves 1...{a} and 1...{b} allow quiet mate
  2.{A}#, while corrected move 1...{c} interposes
  on {c.to} and is captured by 2.{A}#."
---
def [a:N|B|R|Q b c]
key [XA XA A]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  !X.recaptures(a), !X.recaptures(b)
story "Black correction: Key 1.{K}!{threat_clause}.
  Random moves 1...{a} and 1...{b} allow dual mates,
  while corrected move 1...{c} forces 2.{A}#."
---
def [a:B|R|Q b c]
key [XA YA B]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  X.recaptures(a), Y.recaptures(b), !A.recaptures(a),
  !A.recaptures(b), !c.capture
story "Black correction: Key 1.{K}!{threat_clause}.
  Random moves 1...{a} and 1...{b} allow general mate
  2.{A}#, while corrected defense 1...{c} parries 2.{A}#
  and allows 2.{B}#."
---
def [a:N|B|R|Q b c]
key [XA A B]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  a.to != A.to, b.to != A.to
story "Black correction: Key 1.{K}!{threat_clause}.
  Random moves 1...{a} and 1...{b} allow general mate
  2.{A}#, while corrected defense 1...{c} forces 2.{B}#."
---
def [a:N|B|R|Q b c]
key [XA YA B]
where same_piece(a, b, c), distinct(a.to, b.to, c.to),
  a.to != A.to, b.to != A.to
story "Black correction: Key 1.{K}!{threat_clause}.
  Random moves 1...{a} and 1...{b} allow general mate
  2.{A}#, while corrected defense 1...{c} forces 2.{B}#."
```

### Threat correction
**Enum**: `NamedTheme::ThreatCorrection`

White correction where general moves threaten A and corrected move threatens B.

```thema
try Tr1 (A) [!]
try Tr2 (A) [!]
any K (B*)
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to),
  Tr1.threat_count == Tr2.threat_count, A.from != Tr1.to,
  (A.from != B.from || A.to != B.to)
with -match_threat_count -single_refutation
  -capture_try_piece -refutation_is_check
story "Threat correction: Random tries 1.{Tr1}? and
  1.{Tr2}? threatened 2.{A}# (refuted by 1...{a}!);
  1.{K}! corrects the threat to 2.{B}#."
---
try Tr1 (A) [! _]
try Tr2 (A) [_ !]
key K (B)
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to),
  (Tr1.threat_count == Tr2.threat_count
    || K.opens_line(WK) || Tr1.opens_line(WK)
    || Tr1.capture || Tr2.capture),
  (A.from != Tr1.to || B.from != K.to),
  (A.from != B.from || A.to != B.to)
with -match_threat_count -single_refutation
  -capture_try_piece -refutation_is_check
story "Threat correction: Random tries 1.{Tr1}? and
  1.{Tr2}? threatened 2.{A}# (refuted by 1...{a}! and
  1...{b}!); Key 1.{K}! corrects the threat to 2.{B}#."
---
try Tr1 (A) [! _]
try Tr2 (B) [_ !]
key K (C)
where same_piece(Tr1, Tr2, K),
  distinct(Tr1.to, Tr2.to, K.to),
  (K.opens_line(WK) || Tr1.opens_line(WK)
    || A.to == K.from || A.from == Tr1.to
    || B.from == Tr2.to),
  (A.from != C.from || A.to != C.to || B.from != C.from
    || B.to != C.to)
with -match_threat_count -single_refutation
  -capture_try_piece -refutation_is_check
story "Threat correction: Tries 1.{Tr1}? (threat 2.{A}#,
  refuted by 1...{a}!) and 1.{Tr2}? (threat 2.{B}#,
  refuted by 1...{b}!) are corrected by Key 1.{K}!
  (threat 2.{C}#)."
---
try Tr (A)
key K (B)
where same_piece(Tr, K), Tr.to != K.to,
  (K.opens_line(WK) || Tr.opens_line(WK) || A.to == K.from
    || (A.from == Tr.to && B.from != K.to)),
  (A.from != B.from || A.to != B.to)
with -match_threat_count -capture_try_piece
  -refutation_is_check
story "Threat correction: Try 1.{Tr}? threatened 2.{A}#;
  Key 1.{K}! by the same piece corrects the threat
  to 2.{B}#."
```

### Stocchi blocks
**Enum**: `NamedTheme::StocchiBlocks`

Multiple self-blocks on the same flight square answered by different checkmates.

```thema
def [a:!K b:!K c:!K]
key [A B C]
where same_square(a, b, c), (a, b, c).self_block
subsumes DefencesOnSameSquare, Laitinen
story "Stocchi blocks: Key 1.{K}!{threat_clause} answers
  three self-blocks on {a.to} with distinct checkmates:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Secondary black correction
**Enum**: `NamedTheme::SecondaryCorrection`

Three levels of Black defense by the same piece: random move, first correction, and second correction (tertiary mate).

```thema
key [A A B C]
where same_piece(a, b, c, d), a.to < b.to, c.to < d.to,
  distinct(a.to, b.to, c.to, d.to), c.corrects(a),
  d.corrects(a), !c.check, !d.check, B.mate_count == 1,
  C.mate_count == 1
with -match_mate_count
story "Secondary Black correction:
  Key 1.{K}!{threat_clause} meets three tiers of defense
  by the same piece: random move 1...{a} allows 2.{A}#,
  primary correction 1...{c} allows 2.{B}#, and secondary
  correction 1...{d} allows 2.{C}#."
```

### Tertiary black correction
**Enum**: `NamedTheme::TertiaryCorrection`

Four levels of Black defense by the same piece, each distinguishing a further refined checkmate.

```thema
key [A A B C D]
where same_piece(a, b, c, d, e), a.to < b.to, c.to < d.to,
  d.to < e.to, distinct(a.to, b.to, c.to, d.to, e.to),
  c.corrects(a), d.corrects(a), e.corrects(a), !c.check,
  !d.check, !e.check,
  (B.mate_count == 1 && C.mate_count == 1)
    || (B.mate_count == 1 && D.mate_count == 1)
    || (C.mate_count == 1 && D.mate_count == 1)
with -match_mate_count
subsumes SecondaryCorrection
story "Tertiary Black correction:
  Key 1.{K}!{threat_clause} meets four tiers of Black
  defense, each parrying previous flaws only to permit
  distinct mates: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
---
key K (D) [A A B C D]
where same_piece(a, b, c, d, e), a.to < b.to, c.to < d.to,
  d.to < e.to, distinct(a.to, b.to, c.to, d.to, e.to),
  c.corrects(a), d.corrects(a), e.corrects(a), !c.check,
  !d.check, !e.check,
  (B.mate_count == 1 && C.mate_count == 1)
    || (B.mate_count == 1 && D.mate_count == 1)
    || (C.mate_count == 1 && D.mate_count == 1)
with -match_threat_count -match_mate_count
subsumes SecondaryCorrection
story "Tertiary Black correction:
  Key 1.{K}!{threat_clause} meets four tiers of Black
  defense, each parrying previous flaws only to permit
  distinct mates: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
```

### Arrival correction
**Enum**: `NamedTheme::ArrivalCorrection`

Correction by Black based on the arrival square of different defending pieces.

```thema
key [A B C]
where same_square(a, b, c),
  distinct(a.from, b.from, c.from)
subsumes DefencesOnSameSquare, Laitinen
story "Arrival correction: Key 1.{K}!{threat_clause}
  meets correction based on arrival square {a.to}:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Somov (A)
**Enum**: `NamedTheme::SomovA`

Somov theme form A: self-block flaw on the King's field allows mate.

```thema
key [A B C]
where same_square(a, b, c), (a, b, c).self_block,
  distinct(a.from, b.from, c.from)
subsumes ArrivalCorrection
story "Somov A: Key 1.{K}!{threat_clause} exploits
  a self-block flaw on the King's field square {a.to}:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Ural theme
**Enum**: `NamedTheme::Ural`

Three correcting moves in Black corrections are self-blocks.

```thema
def [r1 a r2 b r3 c]
key [T1* A* T2* B* T3* C*]
where a.corrects(r1), b.corrects(r2), c.corrects(r3),
  (a, b, c).self_block, distinct(A, B, C)
with -match_mate_count
subsumes SelfBlock
story "Ural theme: Key 1.{K}!{threat_clause}; three
  correcting moves in Black corrections are self-blocks:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
---
def [a:N|B|R|Q b:N|B|R|Q c:N|B|R|Q]
key [A* B* C*]
where (a, b, c).self_block,
  (same_piece(a, b) || same_piece(b, c)
    || same_piece(a, c)),
  distinct(A, B, C)
with -match_mate_count
subsumes SelfBlock
story "Ural theme: Key 1.{K}!{threat_clause}; three
  correcting moves in Black corrections are self-blocks:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Somov (C)
**Enum**: `NamedTheme::SomovC`

Black correction defense whose secondary flaw is opening a White line of attack toward the Black King.

```thema
def [r a]
key (T) [T A]
where a.corrects(r), a.opens_line(A)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes ThreatKey
story "Somov (C): After Key 1.{K}! (threat 2.{T}#),
  random move 1...{r} allows 2.{T}#, while Black
  correction 1...{a} opens a White line for 2.{A}#."
```

### Somov (E)
**Enum**: `NamedTheme::SomovE`

Black correction defense whose secondary flaw is interfering with a friendly Black line-piece.

```thema
def [r a]
key (T) [T A]
where a.corrects(r), a.parries(T), a.interferes_for(A)
subsumes CrossCheck, LineClosure, ProvokedCheck,
  SelfInterference, ThreatKey
story "Somov (E): After Key 1.{K}! (threat 2.{T}#), random
  move 1...{r} allows 2.{T}#, while Black correction
  1...{a} interferes with a friendly line-piece,
  allowing 2.{A}#."
```

### Mutual Black correction
**Enum**: `NamedTheme::MutualCorrection`

Two distinct Black pieces execute correction moves to the exact same destination square.

```thema
def [r1 a r2 b]
key (T) [T A T B]
where a.corrects(r1), b.corrects(r2), diff_piece(a, b),
  a.to == b.to
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
subsumes DefencesOnSameSquare, Laitinen, ThreatKey
story "Mutual Black correction: Key 1.{K}! (threat 2.{T}#)
  induces two Black pieces to correct on the same square
  {a.to}: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Correction self-block
**Enum**: `NamedTheme::CorrectionSelfBlock`

A Black correction move simultaneously self-blocks a flight square of the Black King, met by a non-capturing mate.

```thema
def [r a]
key (T) [T A]
where a.corrects(r), a.self_block, A.to != a.to
subsumes CrossCheck, ProvokedCheck, SelfBlock, ThreatKey
story "Correction self-block: After Key 1.{K}!
  (threat 2.{T}#), Black correction 1...{a} (correcting
  1...{r}) self-blocks on {a.to}, allowing 2.{A}#."
```

### Kiev theme
**Enum**: `NamedTheme::Kiev` · *Alias*: Kiev

Two tries by a White slider along a line with the same threat are refuted by random and correction moves of a Black Knight; the key along that line answers both.

```thema
def [a:N b:N]
try Tr1 (T) [! _]
try Tr2 (T) [_ !]
key K (T) [A B]
where same_piece(Tr1, Tr2, K), K.slider, same_piece(a, b),
  a.to != b.to
subsumes Isaev, ThreatKey, WhiteCorrection
story "Kiev theme: Slider tries 1.{Tr1}? (1...{a}!)
  and 1.{Tr2}? (1...{b}!) with threat 2.{T}# are solved
  by 1.{K}!, answering 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Anti-Führer
**Enum**: `NamedTheme::AntiFuehrer` · *Alias*: Povenets

A check-provoking key exposes the White King to random and correction checks by a Black Knight, forcing two different White pieces to deliver cross-check mates on the same square.

```thema
def [a:N:+ b:N:+]
key K [A B]
where same_piece(a, b), a.to != b.to, A.from != B.from,
  A.to == B.to
subsumes Barulin, BlackCorrection, CrossCheck,
  ProvokedCheck
story "Anti-Führer (Povenets): Key 1.{K}!{threat_clause}
  provokes Knight checks 1...{a} and 1...{b}, answered
  on {A.to} by 2.{A}# and 2.{B}#."
```

### Velimirovic attack
**Enum**: `NamedTheme::VelimirovicAttack`

White Knight correction tries are refuted by a Black Queen/slider moving to a board corner square.

```thema
try Tr1:N [A !]
try Tr2:N [_ B]
key K:N [C D]
where same_piece(Tr1, Tr2, K),
  (b.to in CORNERS || b.from in CORNERS)
subsumes ChangedPlay, CornerMove
story "Velimirovic attack: White Knight correction tries
  1.{Tr1}? (refuted by corner move 1...{b}!) and 1.{Tr2}?
  lead to Key 1.{K}!."
```

### Anti-Somov A1
**Enum**: `NamedTheme::AntiSomovA1`

In a try and the key (or two variations), Black defenses close lines to allow mates on the same square by two different White pieces.

```thema
try [A B]
key [C D]
where A.to == B.to, A.from != B.from, C.to == D.to,
  C.from != D.from
subsumes Barulin, ChangedPlay
story "Anti-Somov A1: Try 1.{Tr}? (2.{A}#, 2.{B}#
  on {A.to}) and Key 1.{K}! (2.{C}#, 2.{D}# on {C.to})
  swap same-square mates."
```

---

## 08. Checks, Cross-Checks & Counter-Attacks

*Defensive checks parried by cross-checking checkmates, double checks, checking keys, and provoked checks.*

### Cross-Check
**Enum**: `NamedTheme::CrossCheck` · *Alias*: Cross check

Black defense gives check to White King, answered by White checkmate without directly capturing the checking piece.

```thema
def [a:+]
any [A]
where A.fires_battery || !A.recaptures(a)
story "Cross-check: Key 1.{K}!{threat_clause} The
  check 1...{a}+ is answered by the counter-checking
  checkmate 2.{A}#"
```

### Double Check Mate
**Enum**: `NamedTheme::DoubleCheckMate`

White delivers checkmate with a double check.

```thema
key [A]
where A.double_check
story "Double checkmate: Key 1.{K}!{threat_clause}.
  Checkmate 2.{A}# strikes the King from two different
  directions simultaneously."
---
key (A)
where A.double_check
with -match_threat_count
story "Double checkmate: Key 1.{K}! threatens double
  checkmate 2.{A}#."
```

### Checking Key
**Enum**: `NamedTheme::CheckingKey`

The Key move gives check to the Black King.

```thema
key K:+
story "Checking key: Key 1.{K}! boldly opens the solution
  with a direct check to the Black King."
```

### Double check
**Enum**: `NamedTheme::DoubleCheck`

White delivers checkmate with a double check from two distinct pieces simultaneously.

```thema
key [A]
where A.double_check
story "Double check: Key 1.{K}!{threat_clause}.
  White delivers checkmate 2.{A}# with two pieces checking
  simultaneously against 1...{a}."
---
key (A)
where A.double_check
with -match_threat_count
story "Double check: Key 1.{K}! threatens double
  checkmate 2.{A}#."
```

### Check-giving key
**Enum**: `NamedTheme::CheckGivingKey` · *Alias*: Checking Key

White key move delivers check to the Black King.

```thema
key K:+ [A]
with -match_mate_count
subsumes CheckingKey
story "Check-giving key: Key 1.{K}! gives direct check,
  met by 1...{a} 2.{A}#."
```

### Provoked Check
**Enum**: `NamedTheme::ProvokedCheck`

White key invites or provokes a Black check, which is answered by cross-checkmate.

```thema
def [a:+]
key K [A:+]
where K.role == 'K' || a.to == K.to || a.to == K.from
    || between(K.from, a.from, a.to)
    || between(K.from, a.to, WK)
    || collinear(K.from, a.from, WK) || K.unpins(BK)
    || (a.role == 'K' && K.flights_given > 0)
    || K.threat_count == 0
story "Provoked check: White key 1.{K}!{threat_clause}
  invites Black check 1...{a}+, decisively countered
  by checkmate 2.{A}#."
```

### Cross-check key
**Enum**: `NamedTheme::CrossCheckKey`

The problem starts with White in check, and the key parries check while delivering check (or checkmate).

```thema
key K:+ [A]
where start_is_check()
subsumes CheckGivingKey
story "Cross-check key: Key 1.{K}! boldly parries
  a check while delivering check, meeting defense with
  checkmate 2.{A}#."
```

### Double cross-check
**Enum**: `NamedTheme::DoubleCrossCheck`

Two distinct Black checking defenses are met by non-capturing cross-check mates.

```thema
def [a:+ b:+]
key [A!@a B!@b]
story "Double cross-check: Key 1.{K}!{threat_clause}
  meets two Black checks with non-capturing cross-checks:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Triple cross-check
**Enum**: `NamedTheme::TripleCrossCheck`

Three distinct Black checking defenses are answered by distinct cross-check mates.

```thema
def [a:+ b:+ c:+]
key [A B C]
subsumes DoubleCrossCheck, ProvokedCheck
story "Triple cross-check: Key 1.{K}!{threat_clause}
  parries three Black checks with distinct cross-check
  mates: 1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Changed cross-check
**Enum**: `NamedTheme::ChangedCrossCheck`

The same Black checking defense is answered by one cross-check mate in virtual play and by a different cross-check mate in actual play.

```thema
def [a:+]
^vir [A]
^+any [B]
subsumes ChangedMate
story "Changed cross-check: Black check 1...{a} is
  answered by 2.{A}# in {phase1}, and by changed
  cross-check 2.{B}# in {phase2}."
```

### Switchback cross-check
**Enum**: `NamedTheme::SwitchbackCrossCheck`

A Black checking defense is answered by a switchback cross-check mate of the White key piece returning to its origin square.

```thema
def [a:+]
key K [A~K]
subsumes ProvokedCheck, Switchback
story "Switchback cross-check: Key 1.{K}!{threat_clause}
  answers Black check 1...{a} with a switchback return
  to {K.from}: 2.{A}#."
```

### Self-block cross-check
**Enum**: `NamedTheme::SelfBlockCrossCheck`

A Black checking defense simultaneously self-blocks a flight square of the Black King, met by a non-capturing cross-check mate.

```thema
def [a:+]
key [A!@a]
where a.self_block
subsumes SelfBlock
story "Self-block cross-check:
  After Key 1.{K}!{threat_clause}, Black check 1...{a}
  self-blocks on {a.to}, allowing cross-check 2.{A}#."
```

### Theme E
**Enum**: `NamedTheme::ThemeE` · *Alias*: Thema E

Two Black checking defenses on the same square pin or block one of two White pieces, forcing the other to deliver cross-check mate on the same square.

```thema
def [a:+ b:+]
key [A B]
where same_square(a, b), a.from != b.from,
  A.from != B.from, A.to == B.to
subsumes Barulin, DefencesOnSameSquare, Laitinen,
  ProvokedCheck
story "Theme E: Key 1.{K}!{threat_clause}. Checking
  defenses 1...{a} and 1...{b} on {a.to} force distinct
  White cross-checks on {A.to}: 2.{A}# vs 2.{B}#."
```

### Padulli type
**Enum**: `NamedTheme::Padulli` · *Alias*: Padulli

A checking key grants at least two new King flights and replaces set-play mates with completely new flight-variation mates.

```thema
vir [A B _ _]
key K:+ [_ _ C D]
where K.flights_given >= 2, (c, d).role == 'K',
  c.to != d.to
subsumes CheckGivingKey, FlightGivingKey
story "Padulli type: Checking Key 1.{K}! grants flights
  1...{c} 2.{C}# and 1...{d} 2.{D}#, replacing set-play
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Pseudo Umnov 1
**Enum**: `NamedTheme::PseudoUmnov1` · *Alias*: Pseudo Umnov

A Black checking defense vacates a square that White's cross-check mate immediately occupies (Umnov cross-check).

```thema
def [a:+]
key [A@a.from]
where !A.capture
subsumes CrossCheck, ProvokedCheck
story "Pseudo Umnov 1: Key 1.{K}!{threat_clause}.
  Checking defense 1...{a} vacates {a.from}, allowing
  cross-check mate 2.{A}# on {a.from}."
```

---

## 09. King Flights & Board Geometry

*Flights granted to the Black King (stars, crosses, Y-flights, radial wheels) and board extremity play (corners, perimeters).*

### Star Flights
**Enum**: `NamedTheme::StarFlights` · *Alias*: Star flights

Black King has 4 diagonal flight moves in defense, each answered by checkmate.

```thema
def [a:K b:K c:K d:K]
any [A* B* C* D*]
where a.sw, b.se, c.nw, d.ne,
  count_distinct(A, B, C, D) >= 2
with -match_mate_count
subsumes KingFlight
story "Star flights: Key 1.{K}!{threat_clause} The
  Black king flees to all four diagonal flight squares:
  1...{a} allows 2.{A}#; 1...{b} allows 2.{B}#;
  1...{c} allows 2.{C}#; 1...{d} allows 2.{D}#"
```

### Cross Flights
**Enum**: `NamedTheme::CrossFlights` · *Alias*: Cross flights

Black King has 4 orthogonal flight moves in defense, each answered by checkmate.

```thema
def [a:K b:K c:K d:K]
key [A B C D]
where a.south, b.north, c.west, d.east
with -match_mate_count
subsumes KingFlight
story "Cross flights: Key 1.{K}!{threat_clause} The
  Black king darts to all four orthogonal flight squares:
  1...{a} allows 2.{A}#; 1...{b} allows 2.{B}#;
  1...{c} allows 2.{C}#; 1...{d} allows 2.{D}#"
```

### Flight Giving Key
**Enum**: `NamedTheme::FlightGivingKey`

The Key move increases the Black King's available escape flight squares (net flights given ≥ 1).

```thema
key K
where K.flights_given - K.flights_taken > 0
story "Flight-giving key: Key 1.{K}!{threat_clause}
  generously grants flight squares to the Black King."
```

### Corner Move
**Enum**: `NamedTheme::CornerMove`

A thematic move lands on a corner square (a1, a8, h1, h8).

```thema
key K
where K.to.corner
story "Corner move: Key 1.{K}!{threat_clause} moves
  to corner square {K.to}."
---
key K [A]
where !K.to.corner, A.to.corner
story "Corner move: Key 1.{K}!{threat_clause} features
  play to a corner square (1...{a} 2.{A}#)."
```

### Flight Taking Key
**Enum**: `NamedTheme::FlightTakingKey`

The Key move reduces the Black King's available escape flight squares (net flights taken ≥ 1).

```thema
key K
where K.flights_taken - K.flights_given > 0
story "Flight-taking key: Key 1.{K}!{threat_clause}
  restricts the Black King by seizing a vital
  flight square."
```

### Two Flights Giving Key
**Enum**: `NamedTheme::TwoFlightsGivingKey`

The Key move provides a net increase of two escape flight squares to the Black King.

```thema
key K
where K.flights_given - K.flights_taken == 2
subsumes FlightGivingKey
story "Two flights giving key: Key 1.{K}!{threat_clause}
  magnanimously concedes two flight squares
  to the Black King."
```

### Three Flights Giving Key
**Enum**: `NamedTheme::ThreeFlightsGivingKey`

The Key move provides a net increase of three escape flight squares to the Black King.

```thema
key K
where K.flights_given - K.flights_taken == 3
subsumes FlightGivingKey, TwoFlightsGivingKey
story "Three flights giving key: Key 1.{K}!{threat_clause}
  offers three flight squares to the Black King."
```

### Four Flights Giving Key
**Enum**: `NamedTheme::FourFlightsGivingKey`

The Key move provides a net increase of at least four escape flight squares to the Black King.

```thema
key K
where K.flights_given - K.flights_taken >= 4
subsumes FlightGivingKey, ThreeFlightsGivingKey,
  TwoFlightsGivingKey
story "Four flights giving key: Key 1.{K}!{threat_clause}
  offers four flight squares to the Black King."
```

### Smothered Mate
**Enum**: `NamedTheme::SmotheredMate`

Knight checkmate where the Black King is completely surrounded and has 0 flights.

```thema
key [A]
where A.smothered_mate
story "Smothered mate: Key 1.{K}!{threat_clause}.
  The Black King is trapped within its own ranks;
  defense 1...{a} is met by Knight checkmate 2.{A}#."
```

### Mari
**Enum**: `NamedTheme::Mari` · *Alias*: Mari theme

Black defenses open White lines of guard to a flight square (or self-block it), relieving White pieces to abandon their guard and deliver distinct mates.

```thema
key [A B]
where same_square(a, b), a.from != b.from, A != B,
  ((a, b).unpins(BK) || (A.to == b.from
    && B.to == a.from))
story "Mari: Key 1.{K}!{threat_clause}.
  Mutual self-unpinning and cross-checks across defenses
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
---
key K [A B]
where K.threat_count <= 1, a.from != b.from, A != B,
  a.opens_line(WK), b.opens_line(WK), !A.recaptures(a),
  !B.recaptures(b),
  (K.threat_count > 0 || K.flights_given > 0
    || K.active_sacrifice)
story "Mari: Key 1.{K}!{threat_clause}.
  Defenses 1...{a} and 1...{b} open White lines of action,
  enabling mates 2.{A}# and 2.{B}#."
---
key K [A B]
where K.threat_count <= 1, a.to != b.to, A != B,
  a.self_block, b.self_block, A.to != a.to, B.to != b.to,
  attacks(A.from, a.to), !attacks(A.to, a.to),
  attacks(B.from, b.to), !attacks(B.to, b.to)
story "Mari: Key 1.{K}!{threat_clause}. Self-blocks
  1...{a} and 1...{b} allow mates 2.{A}# and 2.{B}# that
  abandon guard of the blocked flight squares."
```

### Flight capture
**Enum**: `NamedTheme::FlightCapture`

Black King captures an attacking or guarding White piece on a flight square.

```thema
def [a:K:x]
key [A]
subsumes KingFlight
story "Flight capture: Key 1.{K}!{threat_clause}.
  Black King captures a piece on a flight square
  (1...{a}), met by checkmate 2.{A}#."
```

### Corner-to-corner
**Enum**: `NamedTheme::CornerToCorner`

A move traveling directly across the chessboard from one corner square to another (rank, file, or diagonal).

```thema
any K [A]
where K.corner_to_corner || A.corner_to_corner
story "Corner-to-corner: Key 1.{K}!{threat_clause}.
  A move traverses the board directly from one corner
  to another, culminating in 2.{A}# against 1...{a}."
```

### Model mate
**Enum**: `NamedTheme::ModelMate`

A pure and economical checkmate: all White pieces (except King and Pawns) participate, and each flight is guarded exactly once.

```thema
key [A]
where A.model_mate
story "Model mate: Key 1.{K}!{threat_clause} leads against
  1...{a} to a model mate 2.{A}# with pure flight control
  and complete piece participation."
```

### Self‑block
**Enum**: `NamedTheme::SelfBlock` · *Alias*: Self-block

Black defense occupies a flight square adjacent to the Black King, taking away that flight and allowing mate.

```thema
key [A!@a]
where a.self_block
with -match_mate_count
story "Self-block: Key 1.{K}!{threat_clause} compels
  defense 1...{a} which deprives the Black King of flight
  square {a.to}, enabling 2.{A}#."
```

### King flight
**Enum**: `NamedTheme::KingFlight`

A defense consisting of the Black King moving to an available flight square.

```thema
def [a:K]
key [A]
story "King flight: Key 1.{K}!{threat_clause} is met
  by Black King flight 1...{a}, promptly answered
  by checkmate 2.{A}#."
```

### Flight-giving and -taking key
**Enum**: `NamedTheme::FlightGivingAndTakingKey`

White key move grants one or more new flights to the Black King while taking away others.

```thema
key K
where K.flights_given > 0, K.flights_taken > 0
story "Flight-giving and -taking key:
  Key 1.{K}!{threat_clause} simultaneously grants new
  flight(s) to the Black King while taking away existing
  flight(s)."
```

### King Y-flight
**Enum**: `NamedTheme::KingYFlight` · *Alias*: Y-flights

Black King has three flight moves forming a Y-shape pattern.

```thema
key K
where BK.y_flight
story "King Y-flight: Key 1.{K}!{threat_clause} grants
  the Black King three flights in a Y-formation."
---
def [a:K b:K c:K]
any [A* B* C*]
where same_piece(a, b, c), count_distinct(A, B, C) >= 2,
  (({a.to, b.to} == {a.from.left_up, a.from.right_up}
    && c.to == a.from.down) || ({a.to, b.to} ==
    {a.from.left_down, a.from.right_down}
    && c.to == a.from.up) || ({a.to, b.to} ==
    {a.from.left_up, a.from.left_down}
    && c.to == a.from.right) || ({a.to, b.to} ==
    {a.from.right_up, a.from.right_down}
    && c.to == a.from.left))
with -match_mate_count
story "King Y-flight: Three King flights forming
  a Y-formation: 1...{a} 2.{A}#, 1...{b} 2.{B}#,
  1...{c} 2.{C}#."
```

### 2 flights taking key
**Enum**: `NamedTheme::TwoFlightsTakingKey`

White key reduces the Black King's available flight squares by at least two (net flights taken ≥ 2).

```thema
key K
where K.flights_taken - K.flights_given >= 2
subsumes FlightTakingKey
story "Two flights taking key: Key 1.{K}!{threat_clause}
  deprives the Black King of two flight squares."
```

### Gockel
**Enum**: `NamedTheme::Gockel` · *Alias*: Gockel theme

Flight-giving key followed by multiple checkmates by the same White piece.

```thema
key K [A B]
where K.flights_given > 0, BK.flights >= 2,
  same_piece(A, B), K.mating_origins == 1
subsumes FlightGivingKey, KingFlight
story "Gockel: Flight-giving key 1.{K}!{threat_clause}
  answers defenses with checkmates by the same piece:
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Unblock
**Enum**: `NamedTheme::Unblock`

A piece vacates an obstructed flight square in the King's field.

```thema
^any K [A* B*]
where K.threat_count > 0, (a, b).role != 'K',
  distance(a.from, BK) == 1, distance(b.from, BK) == 1,
  (distance(a.to, BK) > 1 || A.to == a.from
    || attacks(A.to, a.from) || (!A.fires_battery
    && A.battery_rear >= 0)),
  (distance(b.to, BK) > 1 || B.to == b.from
    || attacks(B.to, b.from) || (!B.fires_battery
    && B.battery_rear >= 0)),
  (a.from != b.from || (A != B && distance(a.to, BK) > 1
    && distance(b.to, BK) > 1 && !(a.check
    && A.recaptures(a)) && !(b.check && B.recaptures(b))))
with -match_threat_count -match_mate_count
  -capture_try_piece -single_refutation
story "Unblock: Flight square unblockings 1...{a} and
  1...{b} are met by checkmates 2.{A}# and 2.{B}#."
---
key K (X) [X* B*]
where (a, b).role != 'K', a.from != b.from,
  distance(a.from, BK) == 1, distance(b.from, BK) == 1,
  distance(a.to, BK) > 1, distance(b.to, BK) > 1
with -match_threat_count -match_mate_count
story "Unblock: Flight square unblockings 1...{a} and
  1...{b} are met by checkmates 2.{X}# and 2.{B}#."
```

### Four corners
**Enum**: `NamedTheme::FourCorners`

Moves to or interactions on all four corner squares of the board (a1, a8, h1, h8).

```thema
key [A B C D]
where (A, B, C, D).to.corner,
  distinct(A.to, B.to, C.to, D.to)
with -match_mate_count
story "Four corners: Key 1.{K}!{threat_clause} reaches all
  four corner squares of the board across variations."
---
key K [A B]
where {K.from, K.to, A.to, B.to} == CORNERS
story "Four corners: Key 1.{K}!{threat_clause} and
  mates 2.{A}#, 2.{B}# visit all four corner squares
  of the board."
---
key K [A B C]
where {A.from, A.to, B.to, C.to} == CORNERS
story "Four corners: After Key 1.{K}!{threat_clause},
  mates 2.{A}#, 2.{B}#, and 2.{C}# from {A.from} visit all
  four corner squares of the board."
---
try T
key K [A]
where {K.from, K.to, T.to, A.to} == CORNERS
story "Four corners: Try 1.{T}?,
  Key 1.{K}!{threat_clause}, and mate 2.{A}# visit all
  four corner squares of the board."
---
try T1
try T2
key K
where {T1.from, T1.to, T2.to, K.to} == CORNERS
story "Four corners: Tries 1.{T1}?, 1.{T2}? and
  Key 1.{K}!{threat_clause} visit all four corner squares
  of the board."
```

### WK star
**Enum**: `NamedTheme::WkStar` · *Alias*: White King star

White King moves in 4 diagonal directions (star formation).

```thema
key [A:K B:K C:K D:K]
where A.nw, B.ne, C.sw, D.se
story "White King star: Key 1.{K}!{threat_clause} leads
  to the White King moving along four diagonal star rays
  across variations: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
---
any A:K
any B:K
any C:K
any D:K
where same_piece(A, B, C, D), A.nw, B.ne, C.sw, D.se
with -refutation_is_check -single_refutation -sparse_mates
  -few_replies -capture_try_piece -match_threat_count
story "White King star: The White King on {A.from}
  steps along all four diagonal star rays across phases:
  1.{A}, 1.{B}, 1.{C}, 1.{D}."
```

### WK cross
**Enum**: `NamedTheme::WkCross` · *Alias*: White King cross

White King moves in 4 orthogonal directions (cross formation).

```thema
key [A:K B:K C:K D:K]
where A.north, B.south, C.west, D.east
subsumes RoyalBattery
story "White King cross: Key 1.{K}!{threat_clause}
  leads to the White King stepping along four orthogonal
  cross directions to deliver mate: 2.{A}#, 2.{B}#,
  2.{C}#, 2.{D}#."
---
any (A:K) [B:K C:K D:K]
where same_piece(A, B, C, D), cross_dirs(A, B, C, D),
  B.dir < C.dir < D.dir
with -match_threat_count -match_mate_count
subsumes RoyalBattery
story "White King cross: Key 1.{K}! (threat 2.{A}#)
  leads to the White King stepping along four orthogonal
  cross directions to deliver mate: 2.{A}#, 2.{B}#,
  2.{C}#, 2.{D}#."
---
any A:K
any B:K
any C:K
any D:K
where same_piece(A, B, C, D), A.north, B.south, C.west,
  D.east
with -refutation_is_check -single_refutation -sparse_mates
  -few_replies -capture_try_piece -match_threat_count
story "White King cross: The White King on {A.from}
  steps along all four orthogonal cross directions across
  phases: 1.{A}, 1.{B}, 1.{C}, 1.{D}."
```

### Radial flights
**Enum**: `NamedTheme::RadialFlights`

Black King has multiple flight moves radiating symmetrically from its square.

```thema
def [a:K b:K c:K d:K]
key [A* B* C* D*]
where a.to < b.to, b.to < c.to, c.to < d.to
with -match_mate_count
subsumes KingFlight
story "Radial flights: Key 1.{K}!{threat_clause} answers
  four symmetrical radiating King flights: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#, 1...{d} 2.{D}#."
```

### Horseblock
**Enum**: `NamedTheme::Horseblock`

A Knight blocks an enemy line or flight square in defense.

```thema
def [a:N b:N c:N d:N]
key [A B C D]
where (a, b, c, d).self_block
subsumes SelfBlock
story "Horseblock: Key 1.{K}!{threat_clause} compels
  a Black Knight to commit self-blocks across variations:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#,
  1...{d} 2.{D}#."
```

### Kettner theme
**Enum**: `NamedTheme::Kettner`

White key creates a direct threat; in at least three variations, Black defenses self-block former Black King flight squares.

```thema
key (X) [A B C]
where (a, b, c).was_flight, (a, b, c).self_block
subsumes SelfBlock, ThreatKey
story "Kettner theme: Key 1.{K}! creates direct threat
  2.{X}#; Black defenses block former flight squares,
  allowing distinct checkmates: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### 2 capture flights
**Enum**: `NamedTheme::TwoCaptureFlights` · *Alias*: Two capture flights

The Black King has at least two distinct legal capture flights on move 1, each met by checkmate.

```thema
def [a:K:x b:K:x]
key [A B]
where a.to != b.to
subsumes FlightCapture
story "Two capture flights: Key 1.{K}!{threat_clause}
  allows the Black King two distinct capture flights:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### King T-flight
**Enum**: `NamedTheme::BkTShapeFlights` · *Alias*: BK T-flight

The Black King has three orthogonal flight squares forming a T-shaped constellation.

```thema
def [a:K b:K c:K]
key [A B C]
where (a, b, c).ortho, distinct(a.to, b.to, c.to)
subsumes KingFlight
story "King T-flight: After Key 1.{K}!{threat_clause},
  the Black King has three orthogonal T-flights:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, and 1...{c} 2.{C}#."
```

### 3 capture flights
**Enum**: `NamedTheme::ThreeCaptureFlights` · *Alias*: Three capture flights

The Black King has at least three distinct legal capture flights on move 1, each met by checkmate.

```thema
def [a:K:x b:K:x c:K:x]
key [A B C]
where distinct(a.to, b.to, c.to)
subsumes TwoCaptureFlights
story "Three capture flights: Key 1.{K}!{threat_clause}
  grants the Black King three capture flights:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, and 1...{c} 2.{C}#."
```

### 4 capture flights
**Enum**: `NamedTheme::FourCaptureFlights` · *Alias*: Four capture flights

The Black King has four distinct legal capture flights on move 1, each met by checkmate.

```thema
def [a:K:x b:K:x c:K:x d:K:x]
key [A B C D]
where distinct(a.to, b.to, c.to, d.to)
with -match_mate_count
subsumes FlightGivingKey, RadialFlights,
  ThreeCaptureFlights
story "Four capture flights: Key 1.{K}!{threat_clause}
  grants the Black King four capture flights:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#,
  and 1...{d} 2.{D}#."
```

### Magnetic Black King
**Enum**: `NamedTheme::MagneticKing`

Three different White pieces deliver contact checkmates on squares immediately adjacent to the Black King.

```thema
key [A B C]
where diff_piece(A, B, C), distance(A.to, BK) == 1,
  distance(B.to, BK) == 1, distance(C.to, BK) == 1
story "Magnetic Black King: After
  Key 1.{K}!{threat_clause}, three distinct White pieces
  deliver contact mates adjacent to the Black King:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Alain C. White theme
**Enum**: `NamedTheme::AlainCWhite`

A flight-giving sacrificial key on a square adjacent to the Black King is captured by three Black pieces (including the Black King and two sliders), producing three distinct mates.

```thema
def [a:Q|R|B:x@K b:Q|R|B:x@K c:K:x@K]
key K [A B C]
where a.from != b.from
subsumes DoubleSacrificeKey, RoyalSacrificeKey
story "Alain C. White theme: Flight-giving sacrificial Key
  1.{K}!{threat_clause} on {K.to} is captured by 1...{a}
  (2.{A}#), 1...{b} (2.{B}#), and King 1...{c} (2.{C}#)."
```

### Kinnunen theme
**Enum**: `NamedTheme::Kinnunen` · *Alias*: Kinnunen

Two moves of a Black pawn self-block two squares around the Black King, while two moves of a Black slider vacate a flight square (unblock) and open lines.

```thema
def [a:P b:P c:B|R|Q d:B|R|Q]
key [A B C D]
where same_piece(a, b), a.self_block, b.self_block,
  same_piece(c, d), c.to != d.to,
  distance(c.from, BK) == 1
subsumes SelfBlock
story "Kinnunen theme: Key 1.{K}!{threat_clause}. Pawn
  self-blocks (1...{a} 2.{A}#, 1...{b} 2.{B}#) contrast
  with slider unblocks (1...{c} 2.{C}#, 1...{d} 2.{D}#)."
```

### Octopus theme
**Enum**: `NamedTheme::Octopus`

A Black Knight adjacent to the Black King executes a wheel of at least six moves that unblock a flight square and self-interfere, forcing six distinct mates.

```thema
def [a:N b:N c:N d:N e:N f:N]
key [A B C D E F]
where same_piece(a, b, c, d, e, f),
  distinct(a.to, b.to, c.to, d.to, e.to, f.to),
  distance(a.from, BK) == 1,
  count_distinct(A, B, C, D, E, F) >= 5
story "Octopus theme: Key 1.{K}!{threat_clause}.
  Black's Knight on {a.from} unblocks and moves to six
  squares (1...{a}..1...{f}), allowing distinct mates."
```

### Four-Hands-Round
**Enum**: `NamedTheme::FourHandsRound`

A square-clearing key allows a White Queen starting on a corner square to deliver mates on at least three other edge/corner squares against Pickabish (Pawn + Bishop) defenses.

```thema
def [a:B b:P c:B d:P]
key K [A:Q B:Q C:Q D:Q]
where same_piece(A, B, C, D), A.from in CORNERS,
  (A.to in CORNERS || B.to in CORNERS || C.to in CORNERS),
  distinct(A.to, B.to, C.to, D.to)
subsumes CornerMove, CornerToCorner
story "Four-Hands-Round: Key 1.{K}!{threat_clause}.
  White's Queen on corner {A.from} tours the board after
  Pickabish defenses: 2.{A}#, 2.{B}#, 2.{C}#, and 2.{D}#."
```

### Segal
**Enum**: `NamedTheme::Segal` · *Alias*: Segal theme

Three Black King flights (Kettner) and two Black slider moves to two of those same flight squares produce five distinct checkmates.

```thema
def [a:K b:K c:K d:R|B|Q e:R|B|Q]
key [A B C D E]
where distinct(a.to, b.to, c.to), same_piece(d, e),
  d.to == a.to, e.to == b.to
subsumes KingFlight
story "Segal: Key 1.{K}!{threat_clause}.
  Three King flights (1...{a}, 1...{b}, 1...{c}) and two
  slider moves to those squares (1...{d}, 1...{e}) produce
  five distinct mates."
```

### Anderssen mate
**Enum**: `NamedTheme::AnderssenMate` · *Alias*: Anderssen's mate

A White King key move grants a flight square to the Black King and then delivers a Royal discovered/capture mate after the Black King moves to that flight.

```thema
def [a:K]
key K:K [A:K]
where K.flights_given >= 1, distance(A.to, BK) <= 2
subsumes FlightGivingKey, KingFlight, RoyalBattery
story "Anderssen mate: White King Key 1.{K}! grants flight
  1...{a} and answers with White King mate 2.{A}#."
```

---

## 10. Piece Wheels, Crosses & Geometric Stars

*Systematic geometric maneuvers by individual pieces (Knight wheel, Rook crosses, Bishop stars, Queen crosses).*

### Knight Wheel
**Enum**: `NamedTheme::KnightWheel`

A Black Knight moves from a single square to all 8 possible squares across defensive variations.

```thema
def [a:N b:N c:N d:N e:N f:N g:N h:N]
key [A B C D E F _ _]
where same_piece(a, b, c, d, e, f, g, h), a.to < b.to,
  b.to < c.to, c.to < d.to, d.to < e.to, e.to < f.to,
  g.to < h.to,
  distinct(a.to, b.to, c.to, d.to, e.to, f.to, g.to, h.to)
with -match_mate_count
story "Knight wheel: Key 1.{K}!{threat_clause}.
  The Black Knight on {a.from} visits all 8 compass
  destinations across defensive variations."
---
def [a:N b:N c:N d:N e:N f:N g:N]
key (T) [A B C D E F _]
where same_piece(a, b, c, d, e, f, g), T.to == a.from,
  a.to < b.to, b.to < c.to, c.to < d.to, d.to < e.to,
  e.to < f.to,
  distinct(a.to, b.to, c.to, d.to, e.to, f.to, g.to)
with -match_mate_count
story "Knight wheel: Key 1.{K}!{threat_clause}.
  The Black Knight on {a.from} visits all 8 compass
  destinations across defensive variations."
```

### White Knight wheel
**Enum**: `NamedTheme::WhiteKnightWheel`

A White Knight delivers moves to 4 or more distinct wheel destinations.

```thema
key [A:N B:N C:N D:N]
where same_piece(A, B, C, D),
  distinct(A.to, B.to, C.to, D.to)
with -match_mate_count
story "White Knight wheel: Key 1.{K}!{threat_clause}.
  White Knight delivers checkmate to wheel squares
  (2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#)."
---
key (ABCD:N)
where same_piece(A, B, C, D),
  distinct(A.to, B.to, C.to, D.to)
with -match_threat_count
story "White Knight wheel: Key 1.{K}! threatens
  a wheel of White Knight checkmates (2.{A}#, 2.{B}#,
  2.{C}#, 2.{D}#)."
---
try Tr1:N
try Tr2:N
try Tr3:N
any K:N
where same_piece(Tr1, Tr2, Tr3, K), Tr1.to < Tr2.to,
  Tr2.to < Tr3.to, distinct(Tr1.to, Tr2.to, Tr3.to, K.to)
with -match_threat_count
story "White Knight wheel: White Knight on {K.from}
  executes a wheel of first moves across tries (1.{Tr1}?,
  1.{Tr2}?, 1.{Tr3}?) and 1.{K}!"
```

### Knight star
**Enum**: `NamedTheme::KnightStar`

A Knight executes moves to all 8 squares arranged in a star/wheel pattern.

```thema
def [a:N b:N c:N d:N e:N f:N g:N h:N]
+key [A* B* C* D* E* F* G* H*]
where same_piece(a, b, c, d, e, f, g, h),
  a.to < b.to < c.to < d.to < e.to < f.to < g.to < h.to
with -match_mate_count
story "Knight star: Key 1.{K}!{threat_clause} compels
  a Black Knight on {a.from} to defend across all eight
  star vectors: 1...{a} 2.{A}#, 1...{b} 2.{B}#."
```

### Black knight star
**Enum**: `NamedTheme::BlackKnightStar`

Black Knight plays to all 8 possible squares.

```thema
def [a:N b:N c:N d:N e:N f:N g:N h:N]
+key [A* B* C* D* E* F* G* H*]
where same_piece(a, b, c, d, e, f, g, h),
  a.to < b.to < c.to < d.to < e.to < f.to < g.to < h.to
with -match_mate_count
subsumes KnightStar
story "Black knight star: Key 1.{K}!{threat_clause}
  compels a Black Knight to defend across all eight
  compass spokes, each met by mate: 1...{a} 2.{A}#,
  1...{b} 2.{B}#."
```

### Defences on the same square
**Enum**: `NamedTheme::DefencesOnSameSquare`

Multiple distinct Black defending pieces arrive at the identical square.

```thema
key K [A B]
where same_square(a, b), a.from != b.from,
  !((a.role == 'K' || b.role == 'K') && a.capture
    && b.capture),
  (K.threat_count > 0 || a.self_block || b.self_block
    || a.capture || b.capture || !(a.opens_line(WK)
    || b.opens_line(WK)))
story "Defenses on same square: Key 1.{K}!{threat_clause}
  meets different Black units defending to the same
  square: 1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Mates on the same square
**Enum**: `NamedTheme::MatesOnSameSquare`

White checkmates arrive at the same destination square across different variations.

```thema
key [A B]
where same_square(A, B), A.from != B.from
story "Mates on same square: Key 1.{K}!{threat_clause}
  allows checkmates arriving on the same square against
  distinct defenses: 1...{a} 2.{A}# vs 1...{b} 2.{B}#."
---
vir [A B]
key [C D]
where same_square(A, C), same_square(B, D),
  A.from != C.from, B.from != D.from
story "Mates on same square: Key 1.{K}!{threat_clause}
  changes checkmates to arrive on the same squares
  with different pieces: 1...{a} 2.{A}# / 2.{C}#,
  1...{b} 2.{B}# / 2.{D}#."
```

### BR cross
**Enum**: `NamedTheme::BrCross` · *Alias*: Black Rook cross

Black Rook defends across 4 orthogonal directions (cross formation).

```thema
def [a:R b:R c:R d:R]
key [A* B* C* D*]
where same_piece(a, b, c, d), a.north, b.south, c.east,
  d.west
with -match_mate_count
story "Black Rook cross: Key 1.{K}!{threat_clause}
  answers a Black Rook defending across four orthogonal
  cross directions: 1...{a} 2.{A}#, 1...{b} 2.{B}#,
  1...{c} 2.{C}#, 1...{d} 2.{D}#."
```

### BB star
**Enum**: `NamedTheme::BbStar` · *Alias*: Black Bishop star

Black Bishop defends along 4 diagonal branches from a central square.

```thema
def [a:B b:B c:B d:B]
key [A B C D]
where same_piece(a, b, c, d),
  count_distinct(A, B, C, D) >= 3, a.ne, b.nw, c.se, d.sw
story "Black Bishop star: Key 1.{K}!{threat_clause}
  compels a Black Bishop to defend along four diagonal
  branches from a central square: 1...{a} 2.{A}#,
  1...{b} 2.{B}#."
```

### WR cross
**Enum**: `NamedTheme::WrCross` · *Alias*: White Rook cross

White Rook delivers moves across 4 orthogonal directions (cross formation).

```thema
any [A:R B:R C:R D:R]
where same_piece(A, B, C, D), A.north, B.south, C.east,
  D.west
with -match_mate_count -single_refutation
  -capture_try_piece
story "White Rook cross: Key 1.{K}!{threat_clause}
  unleashes a White Rook delivering checkmates across four
  orthogonal directions: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
---
any (A:R) [B:R C:R D:R]
where same_piece(A, B, C, D), cross_dirs(A, B, C, D),
  B.dir < C.dir < D.dir
with -match_threat_count -match_mate_count
  -single_refutation -capture_try_piece
story "White Rook cross: Key 1.{K}! (threat 2.{A}#)
  enables a White Rook to branch across all four
  orthogonal directions: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
---
any A:R
any B:R
any C:R
any D:R
where same_piece(A, B, C, D), A.north, B.south, C.east,
  D.west
with -refutation_is_check -single_refutation -sparse_mates
  -few_replies -capture_try_piece -match_threat_count
story "White Rook cross: White Rook on {A.from} branches
  across all four orthogonal directions across phases:
  1.{A}, 1.{B}, 1.{C}, 1.{D}."
---
try (A:R)
try (B:R)
any (C:R) [D:R]
where same_piece(A, B, C, D), cross_dirs(A, B, C, D)
with -match_threat_count -match_mate_count
  -single_refutation -capture_try_piece
story "White Rook cross: White Rook on {A.from} branches
  across all four orthogonal directions across tries and
  key: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
```

### WB star
**Enum**: `NamedTheme::WbStar` · *Alias*: White Bishop star

White Bishop moves along 4 diagonal branches from a central square.

```thema
key [A:B B:B C:B D:B]
where same_piece(A, B, C, D), A.ne, B.nw, C.se, D.sw
story "White Bishop star: Key 1.{K}!{threat_clause}
  enables a White Bishop to branch across four
  diagonal rays to deliver checkmate: 2.{A}#, 2.{B}#,
  2.{C}#, 2.{D}#."
---
key (A:B) [B:B C:B D:B]
where same_piece(A, B, C, D), star_dirs(A, B, C, D),
  B.dir < C.dir < D.dir
story "White Bishop star: Key 1.{K}! (threat 2.{A}#)
  enables a White Bishop to branch across all four
  diagonal rays: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
---
any A:B
any B:B
any C:B
any D:B
where same_piece(A, B, C, D), A.ne, B.nw, C.se, D.sw
with -refutation_is_check -single_refutation -sparse_mates
  -few_replies -capture_try_piece -match_threat_count
story "White Bishop star: White Bishop on {A.from}
  branches across all four diagonal rays across phases:
  1.{A}, 1.{B}, 1.{C}, 1.{D}."
```

### WS wheel
**Enum**: `NamedTheme::WsWheel` · *Alias*: White Knight Wheel

White Knight executes thematic moves across variations in a wheel formation.

```thema
key [A:N B:N C:N D:N E:N F:N G:N H:N]
where same_piece(A, B, C, D, E, F, G, H),
  distinct(A.to, B.to, C.to, D.to, E.to, F.to, G.to, H.to)
subsumes BatteryPlay, WhiteKnightWheel
story "White Knight wheel: Key 1.{K}!{threat_clause}
  unleashes a White Knight completing an eight-spoke wheel
  of checkmates across variations."
---
try Tr1:N
try Tr2:N
try Tr3:N
try Tr4:N
try Tr5:N
try Tr6:N
any K:N
where same_piece(Tr1, Tr2, Tr3, Tr4, Tr5, Tr6, K),
  Tr1.to < Tr2.to, Tr2.to < Tr3.to, Tr3.to < Tr4.to,
  Tr4.to < Tr5.to, Tr5.to < Tr6.to,
  distinct(Tr1.to, Tr2.to, Tr3.to, Tr4.to, Tr5.to, Tr6.to,
    K.to)
with -refutation_is_check -single_refutation -sparse_mates
  -few_replies -capture_try_piece -match_threat_count
story "WS wheel: White Knight on {K.from} executes a wheel
  of moves across tries and 1.{K}!"
---
try Tr1:N
try Tr2:N
try Tr3:N
try Tr4:N
try Tr5:N
try Tr6:N
key [A:N*]
where same_piece(Tr1, Tr2, Tr3, Tr4, Tr5, Tr6, A),
  Tr1.to < Tr2.to, Tr2.to < Tr3.to, Tr3.to < Tr4.to,
  Tr4.to < Tr5.to, Tr5.to < Tr6.to,
  distinct(Tr1.to, Tr2.to, Tr3.to, Tr4.to, Tr5.to, Tr6.to,
    A.to)
with -refutation_is_check -single_refutation -sparse_mates
  -few_replies -capture_try_piece -match_threat_count
  -match_mate_count
story "WS wheel: White Knight on {Tr1.from} executes
  a wheel of moves across tries and checkmate 2.{A}#."
```

### Queen's cross
**Enum**: `NamedTheme::QueensCross` · *Alias*: WQ cross

The White Queen delivers checkmates from the same square along both orthogonal (at least 3) and diagonal (at least 3) cross directions across variations.

```thema
key [A:Q B:Q C:Q D:Q E:Q F:Q]
where same_piece(A, B, C, D, E, F), (A, B, C).ortho,
  (D, E, F).diag, A.to < B.to < C.to, D.to < E.to < F.to
story "Queen's cross: Key 1.{K}!{threat_clause} unleashes
  the White Queen on {A.from} across orthogonal and
  diagonal cross rays: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#,
  2.{E}#, 2.{F}#."
```

### BQ cross
**Enum**: `NamedTheme::BqCross` · *Alias*: Black Queen orthogonal cross

The Black Queen defends along all four orthogonal directions (north, south, east, west) from the same square across variations.

```thema
def [a:Q b:Q c:Q d:Q]
key [A B C D]
where same_piece(a, b, c, d), a.north, b.south, c.east,
  d.west
story "BQ cross: Black Queen on {a.from} defends
  in all four orthogonal directions after
  Key 1.{K}!{threat_clause}: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#, 1...{d} 2.{D}#."
```

### BQ star
**Enum**: `NamedTheme::BqStar` · *Alias*: Black Queen diagonal star

The Black Queen defends along all four diagonal directions from the same square across variations.

```thema
def [a:Q b:Q c:Q d:Q]
key [A B C D]
where same_piece(a, b, c, d), a.ne, b.nw, c.se, d.sw
story "BQ star: Black Queen on {a.from}
  defends in all four diagonal directions after
  Key 1.{K}!{threat_clause}: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#, 1...{d} 2.{D}#."
```

### WQ orthogonal cross
**Enum**: `NamedTheme::WqOrthoCross` · *Alias*: White Queen orthogonal cross

The White Queen delivers checkmates in all four orthogonal directions (north, south, east, west) from the same square.

```thema
key [A:Q B:Q C:Q D:Q]
where same_piece(A, B, C, D), A.north, B.south, C.east,
  D.west
with -match_mate_count
story "WQ orthogonal cross: White Queen on {A.from}
  delivers checkmates in all four orthogonal directions:
  2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
```

### WQ diagonal star
**Enum**: `NamedTheme::WqDiagStar` · *Alias*: White Queen diagonal star

The White Queen delivers checkmates in all four diagonal directions from the same square.

```thema
key [A:Q B:Q C:Q D:Q]
where same_piece(A, B, C, D), A.ne, B.nw, C.se, D.sw
with -match_mate_count
story "WQ diagonal star: White Queen on {A.from}
  delivers checkmates in all four diagonal directions:
  2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
```

---

## 11. Special Rules, Promotions & Tasks

*Orthodox chess rules exploited for composition tasks (Albino, Pickaninny, Allumwandlung / AUW, Excelsior, Castling, En Passant).*

### Pickaninny
**Enum**: `NamedTheme::Pickaninny`

A Black Pawn on its initial square (rank 7) executes all 4 possible pawn moves across defending variations.

```thema
def [a:P b:P c:P d:P]
^any [A* B* C* D*]
where pawn_quartet(a, b, c, d),
  count_distinct(A, B, C, D) >= 3
with -match_mate_count
story "Pickaninny: Key 1.{K}!{threat_clause} The Black
  pawn on {a.from} exhausts all four compass defenses:
  1...{a} allows 2.{A}#; 1...{b} allows 2.{B}#;
  1...{c} allows 2.{C}#; 1...{d} allows 2.{D}#"
---
def [a:P b:P c:P]
key (T) [A* B* C*]
where same_piece(a, b, c), a.from.rank == 7,
  T.to == a.from, a.to < b.to, b.to < c.to,
  distinct(T, A, B, C)
with -match_mate_count
story "Pickaninny: Key 1.{K}! (threat 2.{T}#) compels
  the Black pawn on {a.from} to exhaust all four compass
  defenses: 1...{a} allows 2.{A}#; 1...{b} allows 2.{B}#;
  1...{c} allows 2.{C}#"
```

### Allumwandlung
**Enum**: `NamedTheme::Allumwandlung` · *Alias*: AUW

Promotions to all four roles (Queen, Rook, Bishop, Knight) appear across White mating moves.

```thema
key [A:= B:= C:= D:=]
where distinct(A.promotion, B.promotion, C.promotion,
    D.promotion)
subsumes PromotionKey
story "Allumwandlung (AUW): Key 1.{K}!{threat_clause}
  White completes the fourfold promotion cycle
  in checkmate: 2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#"
```

### Underpromotion
**Enum**: `NamedTheme::Underpromotion`

White promotes to a piece other than a Queen (Rook, Bishop, or Knight) in the key or checkmate.

```thema
key [A:=!Q]
story "Underpromotion: Key 1.{K}!{threat_clause} White
  delivers checkmate by promoting to a {A.promotion}:
  2.{A}#"
---
key K:=!Q
subsumes PromotionKey
story "Underpromotion: Key 1.{K}!{threat_clause} promotes
  a pawn to a {K.promotion}."
```

### Castling Key
**Enum**: `NamedTheme::CastlingKey` · *Alias*: Castling

White or Black executes castling (kingside or queenside) in key, try, or defense.

```thema
any K [A*]
where K.castling || a.castling
with -single_refutation -capture_try_piece
  -match_threat_count -match_mate_count -sparse_mates
  -few_replies -refutation_is_check
story "Castling: 1.{K} features castling in play
  (1...{a} 2.{A}#)."
---
try K [!]
where K.castling || a.castling
with -single_refutation -capture_try_piece
  -match_threat_count -sparse_mates -few_replies
  -refutation_is_check
story "Castling: Try 1.{K}? features castling in play
  (refuted by 1...{a}!)."
```

### Castling Mate
**Enum**: `NamedTheme::CastlingMate`

White delivers or threatens checkmate by castling.

```thema
any [A]
where A.castling
with -single_refutation -capture_try_piece
  -match_threat_count -match_mate_count -sparse_mates
  -few_replies -refutation_is_check
story "Castling mate: Key 1.{K}!{threat_clause} The attack
  concludes with a castling checkmate 2.{A}#"
---
any (T)
where T.castling
with -single_refutation -capture_try_piece
  -match_threat_count -sparse_mates -few_replies
  -refutation_is_check
story "Castling mate: 1.{K} threatens a castling
  checkmate 2.{T}#."
```

### En Passant
**Enum**: `NamedTheme::EnPassant`

Checkmate or defense played via en passant capture.

```thema
any [A*]
where a.ep || A.ep
with -single_refutation -capture_try_piece
  -match_threat_count -match_mate_count -sparse_mates
  -few_replies -refutation_is_check
story "En passant: Key 1.{K}!{threat_clause}.
  Defense 1...{a} allows checkmate with an en passant
  capture: 2.{A}#."
---
try [!]
where a.ep
with -single_refutation -capture_try_piece
  -match_threat_count -sparse_mates -few_replies
  -refutation_is_check
story "En passant: Try 1.{Tr}? is refuted by the en
  passant capture 1...{a}!."
```

### Promotion Key
**Enum**: `NamedTheme::PromotionKey` · *Alias*: Promotion mate

The Key, Try, Defense, or Mate move is a pawn promotion.

```thema
any K:=
story "Promotion key: Move 1.{K}!{threat_clause} promotes
  a pawn to unleash the decisive attack."
---
any [A]
where A.is_promotion || a.is_promotion
with -match_mate_count
story "Promotion: Key 1.{K}!{threat_clause} features pawn
  promotion in play: 1...{a} 2.{A}#."
```

### Excelsior
**Enum**: `NamedTheme::Excelsior`

A pawn moves from its starting square (rank 2) all the way to promotion mate (requires at least 5 moves; cannot occur in a #2).

```thema
key K:P [A:P:=]
where K.from.rank == 2, same_piece(K, A)
subsumes PromotionKey
story "Excelsior: Pawn begins its epic march with
  key 1.{K}!{threat_clause}, culminating in promotion
  checkmate 2.{A}# against 1...{a}."
```

### Valladao
**Enum**: `NamedTheme::Valladao` · *Alias*: Valladão task

The task featuring castling, en passant capture, and pawn promotion in the same problem.

```thema
key K [A B]
where (K.castling || a.castling || b.castling
    || A.castling || B.castling),
  (a.ep || A.ep),
  (K.is_promotion || b.is_promotion || B.is_promotion)
with -match_mate_count
subsumes CastlingKey, EnPassant, PromotionKey
story "Valladão task: Complete triad of castling,
  en passant capture, and pawn promotion in Key
  1.{K}!{threat_clause} (1...{a} 2.{A}#, 1...{b} 2.{B}#)."
```

### Pape theme
**Enum**: `NamedTheme::Pape`

En passant captures executed by Black in defense.

```thema
key [A B]
where (a, b).ep
subsumes DefencesOnSameSquare, EnPassant, Laitinen
story "Pape theme: Key 1.{K}!{threat_clause} meets
  en passant defenses with checkmates: 1...{a} 2.{A}#
  vs 1...{b} 2.{B}#."
```

### Black underpromotion
**Enum**: `NamedTheme::BlackUnderpromotion` · *Alias*: Underpromotion (Black)

A Black pawn promotes to a minor piece or Rook (Knight, Bishop, or Rook) as a defensive variation, met by a distinct mate.

```thema
def [a:= b:=]
key [A B]
where same_piece(a, b), a.to == b.to,
  a.promotion != b.promotion
story "Black underpromotion: Key 1.{K}!{threat_clause}
  meets Black pawn promotions on {a.to} with distinct
  checkmates: 1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Promotion cross
**Enum**: `NamedTheme::PromotionCross`

White Pawn(s) deliver checkmate by promoting on three distinct squares on the 8th rank across variations.

```thema
key [A:= B:= C:=]
where distinct(A.to, B.to, C.to)
subsumes PromotionKey
story "Promotion cross: After Key 1.{K}!{threat_clause},
  White promotes on three distinct 8th-rank squares:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Superalbino
**Enum**: `NamedTheme::Superalbino`

A White pawn executes all four Albino checkmates (one-step, two-step, left capture, right capture) plus a fifth variation where a White piece mates on that pawn's square.

```thema
key [A:P B:P C:P D:P E]
where pawn_quartet(A, B, C, D), E.to == A.from,
  E.from != A.from
subsumes Albino, BatteryMate, BatteryPlay
story "Superalbino: Key 1.{K}!{threat_clause}.
  White's pawn on {A.from} executes all four Albino
  mates (2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#) plus capture
  1...{e} 2.{E}# on {A.from}."
```

### Isardam
**Enum**: `NamedTheme::Isardam` · *Alias*: Isardam theme

A White pawn promotes on the key move to one piece type, and in three variations a White pawn promotes to the remaining three piece types (Allumwandlung split between key and mates).

```thema
key K:P:= [A:P:= B:P:= C:P:=]
where {K.promotion, A.promotion, B.promotion, C.promotion}
    == {'Q', 'R', 'B', 'N'}
subsumes Allumwandlung
story "Isardam: Promotion Key 1.{K}! ({K.promotion})
  and variation promotions 2.{A}# ({A.promotion}),
  2.{B}# ({B.promotion}), and 2.{C}# ({C.promotion})
  complete a fourfold Allumwandlung."
```

---

## 12. Mating Net Types & Aesthetic Properties

*Checkmate geometry and economy (Model mates, Pure mates, Ideal mates, Mirror mates, Smothered mates, Epaulette mates, Echo mates).*

### Pure mate
**Enum**: `NamedTheme::PureMate`

Every square in the Black King's field is either blocked by a Black piece or guarded by exactly one White unit.

```thema
key [A]
where A.pure_mate
story "Pure mate: Key 1.{K}!{threat_clause} answers
  1...{a} with a pure mate 2.{A}# where every flight
  square is guarded exactly once."
```

### Mirror mate
**Enum**: `NamedTheme::MirrorMate`

A checkmate position where no square in the Black King's field is occupied by any piece.

```thema
key [A]
where A.mirror_mate
story "Mirror mate: Key 1.{K}!{threat_clause} answers
  1...{a} with checkmate 2.{A}# leaving all eight adjacent
  flight squares vacant."
```

### Ideal mate
**Enum**: `NamedTheme::IdealMate`

A model mate in which all pieces of both colors present on the board participate.

```thema
key [A]
where A.ideal_mate
subsumes ModelMate
story "Ideal mate: Key 1.{K}!{threat_clause} answers
  1...{a} with an ideal mate 2.{A}# with every piece
  on the board participating."
```

### Echo mate
**Enum**: `NamedTheme::EchoMate`

Two or more checkmates that have identical geometric shape and piece relationships transposed or rotated.

```thema
key [A* B*]
where (A.to < B.to || (a.role == 'K' && b.role == 'K'
    && a.to < b.to)),
  A.echo(B)
story "Echo mate: Key 1.{K}!{threat_clause} delivers
  checkmates 2.{A}# and 2.{B}# that mirror each other
  in identical geometric shapes: 1...{a} vs 1...{b}."
---
key (XY) [A* B*]
where (A.to < B.to || (a.role == 'K' && b.role == 'K'
    && a.to < b.to)),
  A.echo(B)
with -match_threat_count
story "Echo mate: Key 1.{K}!{threat_clause} delivers
  checkmates 2.{A}# and 2.{B}# that mirror each other
  in identical geometric shapes: 1...{a} vs 1...{b}."
---
vir [A _]
key [_ B]
where A.to != B.to, A.echo(B)
story "Echo mate: Checkmates 2.{A}# in {phase1} and
  2.{B}# after Key 1.{K}!{threat_clause} mirror each other
  in identical geometric shapes."
```

### Chameleon echo
**Enum**: `NamedTheme::ChameleonEcho`

Echo checkmates occurring on squares of opposite board colors.

```thema
def [a:K b:K]
key [A B]
where a.to < b.to, A.chameleon_echo(B)
subsumes KingFlight
story "Chameleon echo: Key 1.{K}!{threat_clause}
  delivers echo checkmates on squares of opposite color:
  1...{a} 2.{A}# vs 1...{b} 2.{B}."
---
def [a:K]
key (A) [B]
where A.chameleon_echo(B)
subsumes KingFlight
story "Chameleon echo: Key 1.{K}! threatens 2.{A}# and
  answers King flight 1...{a} with echo checkmate 2.{B}#
  on a square of opposite color."
```

### Epaulette mate
**Enum**: `NamedTheme::EpauletteMate`

Checkmate where the Black King is flanked on opposite sides by its own pieces (epaulettes) blocking escape.

```thema
key [A]
where A.epaulette_mate
story "Epaulette mate: Key 1.{K}!{threat_clause} delivers
  checkmate 2.{A}# against 1...{a} with the Black King
  flanked on both sides by friendly units."
```

### Asymmetrical
**Enum**: `NamedTheme::Asymmetrical`

An apparently symmetrical position where the solution uniquely breaks symmetry.

```thema
key K
where is_position_symmetric() || has_symmetric_try()
story "Asymmetrical: Key 1.{K}!{threat_clause} breaks
  the apparent symmetry of the position."
```

### Anti-dual
**Enum**: `NamedTheme::AntiDual` · *Alias*: Dual avoidance

Dual checkmates are separated across defenses.

```thema
key K [A!@a B!@b]
try (AB) [_ _]
where K.threat_count <= 1, same_piece(a, b)
with -match_threat_count -capture_try_piece
story "Anti-dual: Try 1.{Tr}? threatened dual mates;
  Key 1.{K}!{threat_clause} cleanly separates them:
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
---
key [AB A B]
where (same_piece(A, B) && !A.recaptures(b)
    && !B.recaptures(c)) || same_piece(a, b)
    || same_piece(a, c) || same_piece(b, c)
story "Anti-dual: Key 1.{K}!{threat_clause} separates dual
  checkmates: defense 1...{a} allows duals, while 1...{b}
  and 1...{c} force unique mates 2.{A}# and 2.{B}#."
---
def [a b]
key K [A B]
where a.role != 'K', same_piece(a, b), a.to != b.to,
  same_piece(A, B), A.to != B.to, !A.recaptures(a),
  !B.recaptures(b),
  ((!a.capture && !b.capture) || (K.threat_count == 0
    && (!a.capture || !b.capture))),
  ((a.unpins(A) && b.unpins(B)) || (a.self_pins_for(A)
    && b.self_pins_for(B)) || (a.self_block
    && b.self_block) || (a.cuts_enemy_line()
    && b.cuts_enemy_line()))
story "Anti-dual: Key 1.{K}!{threat_clause} forces dual
  avoidance by the same White piece across defenses
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
key [A B]
where same_piece(a, b), a.to != b.to, same_square(A, B),
  A.from != B.from, A.role == B.role
story "Anti-dual: Key 1.{K}!{threat_clause} forces dual
  avoidance on {A.to} between 2.{A}# (after 1...{a}) and
  2.{B}# (after 1...{b})."
---
def [a:!x b:!x]
key [A B]
where same_piece(a, b), a.to != b.to, A.from != B.from,
  A.role == B.role, A.to != B.to,
  (a.to == B.to || attacks(a.to, B.to)),
  (b.to == A.to || attacks(b.to, A.to))
story "Anti-dual: Key 1.{K}!{threat_clause} forces dual
  avoidance between 2.{A}# (after 1...{a}) and 2.{B}#
  (after 1...{b})."
---
key (AB) [A B]
where !A.recaptures(a), !B.recaptures(b)
story "Anti-dual: Key 1.{K}! threatens 2.{A}# and 2.{B}#;
  defenses 1...{a} and 1...{b} force dual avoidance
  between 2.{A}# and 2.{B}#."
```

### Symmetrical
**Enum**: `NamedTheme::Symmetrical` · *Alias*: Symmetric position

The diagram position is geometrically symmetric.

```thema
key K
where is_position_symmetric()
story "Symmetrical: The initial diagram
  position is geometrically symmetric, solved
  by 1.{K}!{threat_clause}."
```

### Double model mate
**Enum**: `NamedTheme::DoubleModelMate`

At least two distinct defensive variations end in model checkmates.

```thema
key [A B]
where (A, B).model_mate
subsumes DoublePureMate, ModelMate
story "Double model mate: Key 1.{K}!{threat_clause}
  produces two distinct model checkmates: 1...{a} 2.{A}#
  and 1...{b} 2.{B}#."
```

### Triple model mate
**Enum**: `NamedTheme::TripleModelMate`

At least three distinct defensive variations end in model checkmates.

```thema
key [A B C]
where (A, B, C).model_mate
subsumes DoubleModelMate
story "Triple model mate: Key 1.{K}!{threat_clause}
  produces three distinct model checkmates:
  1...{a} 2.{A}#, 1...{b} 2.{B}#, and 1...{c} 2.{C}#."
```

### Double pure mate
**Enum**: `NamedTheme::DoublePureMate`

At least two distinct defensive variations end in pure checkmates.

```thema
key [A B]
where (A, B).pure_mate
subsumes PureMate
story "Double pure mate: Key 1.{K}!{threat_clause}
  produces two distinct pure checkmates: 1...{a} 2.{A}#
  and 1...{b} 2.{B}#."
```

### Double mirror mate
**Enum**: `NamedTheme::DoubleMirrorMate`

At least two distinct defensive variations end in mirror checkmates (all 8 squares around the Black King vacant).

```thema
key [A B]
where (A, B).mirror_mate
subsumes MirrorMate
story "Double mirror mate: Key 1.{K}!{threat_clause}
  produces two distinct mirror checkmates:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

---

## 13. Tactical Motifs, Sacrifices & Maneuvers

*Fundamental composition motifs (Active and passive sacrifices, decoys, deflections, self-blocks, unguards, ambushes, switchbacks, Umnov, Focal).*

### Switchback
**Enum**: `NamedTheme::Switchback`

A piece returns to the square it departed from (e.g. key piece returns to its origin on move 2 to deliver mate).

```thema
key K [A~K]
with -unique_mate
story "Switchback: Key 1.{K}!{threat_clause} returns
  to origin on move 2 to deliver checkmate: 2.{A}#"
---
key K (A~K)
with -match_threat_count
story "Switchback: Key 1.{K}! threatens a switchback
  checkmate returning to {K.from}: 2.{A}#."
```

### Umnov
**Enum**: `NamedTheme::Umnov` · *Alias*: White Umnov

White mating move occupies the square just vacated by the Black defending piece.

```thema
key [A*@a.from]
with -match_mate_count
story "Umnov vacation-occupation:
  Key 1.{K}!{threat_clause} White occupies the square
  {a.from} just vacated by Black defense 1...{a}: 2.{A}#"
```

### Laitinen
**Enum**: `NamedTheme::Laitinen`

Key K threatens a non-capturing pawn advance X; Black defenses a and b mechanically block square X.to, leading to distinct mates A and B.

```thema
key K (X:P:!x) [A B]
where a.to == X.to, b.to == X.to, a.from != b.from
subsumes DefencesOnSameSquare
story "Laitinen: Key 1.{K}! (threat 2.{X}#). Black
  defenses mechanically block {X.to} with dual avoidance:
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Ambush key
**Enum**: `NamedTheme::AmbushKey` · *Alias*: Ambush

A line-moving piece moves behind an obstacle piece on a line of action towards the Black King or field.

```thema
key K [A]
where K.slider, A.fires_battery,
  !collinear(K.from, A.from, BK), A.battery_rear == K.to,
  ray_clear(K.to, A.from)
story "Ambush key: Key 1.{K}!{threat_clause} lies
  in ambush behind an obstacle piece, preparing discovered
  checkmate 2.{A}# against 1...{a}."
---
key K (T?) [A]
where K.slider, A.from == K.to,
  !collinear(K.from, K.to, a.from),
  between(a.from, K.to, A.to),
  !collinear(K.to, a.to, A.to), ray_clear(K.to, a.from),
  (K.threat_count != 1 || T.to != a.from)
with -match_threat_count
story "Ambush key: Key 1.{K}!{threat_clause} lies
  in ambush behind {a.from}; when 1...{a} vacates
  the line, 2.{A}# delivers checkmate."
---
key K [A]
where K.threat_count == 0, K.slider, A.from != K.to,
  A.to != a.from, !collinear(K.from, K.to, a.from),
  ray_clear(K.to, a.from), !collinear(K.to, a.from, a.to),
  (between(a.from, K.to, BK)
    || between(a.from, K.to, BK.north)
    || between(a.from, K.to, BK.south)
    || between(a.from, K.to, BK.east)
    || between(a.from, K.to, BK.west)
    || between(a.from, K.to, BK.ne)
    || between(a.from, K.to, BK.nw)
    || between(a.from, K.to, BK.se)
    || between(a.from, K.to, BK.sw)),
  ((K.role in {'R', 'Q'} && (K.to.file == a.from.file
    || K.to.rank == a.from.rank)) || (K.role in {'B', 'Q'}
    && (K.to.file != a.from.file
    && K.to.rank != a.from.rank)))
story "Ambush key: Key 1.{K}!{threat_clause} moves into
  ambush behind {a.from} aiming into the Black King's
  field, enabling 2.{A}# after 1...{a}."
```

### Decoy
**Enum**: `NamedTheme::Decoy`

A piece is lured onto a disadvantageous square by an attractive sacrifice or check.

```thema
def [a:x@K]
key K [A]
where a.role != 'K', a.flight_block
subsumes ActiveSacrifice
story "Decoy: Key 1.{K}!{threat_clause} lures a Black
  piece onto {a.to} (1...{a}), enabling checkmate 2.{A}#."
---
def [a:x b:x c:x]
key (X@a.from) [A@a B@b C@c]
where same_piece(a, b, c), distinct(a.to, b.to, c.to)
story "Decoy: Key 1.{K}!{threat_clause} decoys Black's
  {a.piece} on {a.from} onto {a.to}, {b.to}, and {c.to},
  met by recaptures 2.{A}#, 2.{B}#, and 2.{C}#."
```

### Annihilation
**Enum**: `NamedTheme::Annihilation` · *Alias*: Capture of obstacle

A defending or obstructing piece is eliminated by direct capture.

```thema
def [a:x]
key [A]
where (A.recaptures(a) || between(a.to, A.from, A.to)),
  A.fires_battery
subsumes BatteryMate, BatteryPlay
story "Annihilation: Key 1.{K}!{threat_clause} provokes
  1...{a} which captures an obstructing piece, opening
  the line for checkmate 2.{A}#."
```

### Sacrificial key
**Enum**: `NamedTheme::SacrificialKey`

White key places a piece where it can be captured by Black (sacrifice).

```thema
def [a:x@K b:x@K]
key K [A B]
where a.from != b.from
with -match_mate_count
subsumes ActiveSacrifice, DefencesOnSameSquare, Laitinen
story "Sacrificial key: Key 1.{K}!{threat_clause}
  offers the key piece for capture: 1...{a} 2.{A}#
  vs 1...{b} 2.{B}#."
---
def [a:x@K b:x@K]
key K (AB) [A B]
where a.from != b.from
with -match_threat_count -match_mate_count
subsumes ActiveSacrifice, DefencesOnSameSquare, Laitinen
story "Sacrificial key: Key 1.{K}!{threat_clause}
  offers the key piece for capture: 1...{a} 2.{A}#
  vs 1...{b} 2.{B}#."
---
def [a:x@K b:x@K]
key K (A*) [A B]
where a.from != b.from
with -match_threat_count -match_mate_count
subsumes ActiveSacrifice, DefencesOnSameSquare, Laitinen
story "Sacrificial key: Key 1.{K}!{threat_clause}
  offers the key piece for capture: 1...{a} 2.{A}#
  vs 1...{b} 2.{B}#."
```

### Passive sacrifice
**Enum**: `NamedTheme::PassiveSacrifice`

White key leaves an already attacked piece on its square to be captured.

```thema
def [a:x]
key K [A]
where a.to != K.to, K.passive_sacrifice
story "Passive sacrifice: Key 1.{K}!{threat_clause} leaves
  the piece on {a.to} en prise (1...{a} 2.{A}#)."
---
key K
where K.passive_sacrifice
story "Passive sacrifice: Key 1.{K}!{threat_clause}
  quietly leaves a White piece where Black may
  capture it."
```

### Roman decoy
**Enum**: `NamedTheme::RomanDecoy` · *Alias*: Roman theme

A Black defending piece is decoyed to a square where its defensive power is diminished by a new weakness.

```thema
def [a:x@K]
key K [A]
where A.from != K.to,
  (a.obstructs(A) || (a.slider && K.cuts_enemy_line()
    && !A.recaptures(a)))
with -match_mate_count
subsumes SelfInterference
story "Roman decoy: Key 1.{K}!{threat_clause}
  decoys a Black piece, turning defense 1...{a} into
  checkmate 2.{A}#."
```

### Deflection
**Enum**: `NamedTheme::Deflection`

A defending piece is forced away from defending a vital square or piece.

```thema
key [A!@a]
where a.role != 'K', guards(a.from, A.to),
  !guards(a.to, A.to)
story "Deflection: Key 1.{K}!{threat_clause}
  deflects Black defense 1...{a} away from defending
  against 2.{A}#."
```

### Continued attack
**Enum**: `NamedTheme::ContinuedAttack`

White delivers checkmate by moving the same piece that delivered the key or previous threat.

```thema
key (Thr) [A]
where same_piece(A, Thr), !(A.capture && A.recaptures(a))
story "Continued attack: Key 1.{K}! introduces threat
  2.{Thr}#, followed by checkmate 2.{A}# by the same piece
  against 1...{a}."
```

### Active sacrifice
**Enum**: `NamedTheme::ActiveSacrifice`

White key moves a piece onto an attacked square where Black can capture it.

```thema
key K
where K.active_sacrifice
story "Active sacrifice: Key 1.{K}!{threat_clause}
  forcefully places a piece en prise to shatter
  Black's defense."
```

### Queen sacrifice
**Enum**: `NamedTheme::QueenSacrifice`

White sacrifices the Queen in key or defense variation.

```thema
key K [A]
where (K.role == 'Q' && a.recaptures(K)) || (a.is_capture
    && a.to == A.from)
subsumes ActiveSacrifice
story "Queen sacrifice: White heroically sacrifices
  the Queen with Key 1.{K}!{threat_clause}, crushing
  1...{a} with 2.{A}#."
```

### Chernet theme
**Enum**: `NamedTheme::Chernet`

White key and try are made by the same piece which sacrifices itself on two different squares, try not refuted by capture.

```thema
try Tr [!]
key K
where same_piece(Tr, K), Tr.to != K.to, K.sacrifice,
  Tr.sacrifice, a.to != Tr.to, Tr.threat_count >= 1,
  K.threat_count >= 1,
  (K.threat_count <= 1 || Tr.threat_count <= 1
    || K.capture || Tr.capture)
subsumes ActiveSacrifice
story "Chernet theme: Key 1.{K}!{threat_clause} and try
  1.{Tr}? (refuted by 1...{a}!) are moves by the same
  White piece sacrificing on different squares."
```

### Balbo theme
**Enum**: `NamedTheme::Balbo`

In at least three variations, the Black defending piece and the White mating piece have the same piece type, across three distinct piece types.

```thema
key [A B C]
where a.role == A.role, b.role == B.role,
  c.role == C.role, distinct(a.role, b.role, c.role)
story "Balbo theme: Key 1.{K}!{threat_clause} matches
  Black defending roles with identical White mating piece
  roles: 1...{a} 2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#."
```

### Anti-Balbo
**Enum**: `NamedTheme::AntiBalbo`

Defenses prevent the Balbo pattern.

```thema
try T1 [! _ _]
try T2 [_ ! _]
try T3 [_ _ !]
key K
where T1.role == a.role, T2.role == b.role,
  T3.role == c.role, distinct(T1.role, T2.role, T3.role)
with -capture_try_piece -refutation_is_check
  -single_refutation -match_threat_count
story "Anti-Balbo: Black defenses parry White's Balbo
  attempts (1.{T1}?, 1.{T2}?, 1.{T3}?), resolved
  by Key 1.{K}!{threat_clause}."
```

### Mule theme
**Enum**: `NamedTheme::Mule`

Two self-blocks by Black Knights and two self-blocks by Black Bishops across four variations.

```thema
def [a:N b:N c:B d:B]
key [A B C D]
where (a, b, c, d).self_block
subsumes SelfBlock
story "Mule theme: Key 1.{K}!{threat_clause} induces
  self-blocks by Black Knights and Bishops: 1...{a}
  2.{A}#, 1...{b} 2.{B}#, 1...{c} 2.{C}#, 1...{d} 2.{D}#."
```

### Multiple captures of White piece
**Enum**: `NamedTheme::MultipleCaptures`

The same White piece is captured by different Black units across defending variations.

```thema
def [a:x b:x c:x]
key [A B C]
where a.to == b.to == c.to,
  distinct(a.from, b.from, c.from)
subsumes ArrivalCorrection
story "Multiple captures: Key 1.{K}!{threat_clause}
  provokes three different Black units to capture the same
  White piece on {a.to}: 1...{a} 2.{A}#, 1...{b} 2.{B}#,
  1...{c} 2.{C}#."
```

### Kozhakin theme
**Enum**: `NamedTheme::Kozhakin`

First and last White moves arrive on the same square (key and mate arrive on same square).

```thema
key K [A@K]
story "Kozhakin: Key 1.{K}!{threat_clause} and checkmate
  2.{A}# arrive on the identical square {K.to} against
  defense 1...{a}."
```

### Stavrinides
**Enum**: `NamedTheme::Stavrinides` · *Alias*: Stavrinides cycle

Chained square-to-square Umnov cycle across variations: defense avacates/plays to square of mate A, defense b plays to square of mate B, closing a cycle back to defense a.

```thema
key [A B]
where A.to == b.to, B.to == a.to, A.to != B.to
story "Stavrinides: Circular square-to-square
  Umnov cycle after Key 1.{K}!{threat_clause}:
  1...{a} (on {a.to}) allows 2.{A}# (on {A.to}),
  while 1...{b} (on {b.to}) allows 2.{B}# (on {B.to})."
```

### Black Umnov
**Enum**: `NamedTheme::BlackUmnov`

A Black defense moves onto the exact square vacated by the White key piece (a.to == K.from).

```thema
def [a@K.from]
key K [A]
story "Black Umnov: Key 1.{K}!{threat_clause} vacates
  {K.from}, and Black defense 1...{a} immediately occupies
  {a.to}, allowing checkmate 2.{A}#."
```

### Threat return
**Enum**: `NamedTheme::ThreatReturn` · *Alias*: Threat Switchback

The threat created by the key move is a switchback of the key piece returning to its departure square.

```thema
key K (T~K)
subsumes Switchback
story "Threat return: Key 1.{K}! threatens an immediate
  switchback return of the {K.role_name} to its origin
  square: 2.{T}#."
```

### Rook sacrifice
**Enum**: `NamedTheme::RookSacrifice`

White actively sacrifices a Rook on the key move.

```thema
def [a:x@K]
key K:R [A]
subsumes ActiveSacrifice
story "Rook sacrifice: Key 1.{K}!{threat_clause}
  sacrifices a White Rook on {K.to}, met
  by 1...{a} 2.{A}#."
```

### Coulomb theme
**Enum**: `NamedTheme::Coulomb` · *Alias*: Coulomb

A Black defense moves along a line toward a White slider, shortening its range while allowing a non-capturing mate by that slider.

```thema
def [a:!x]
key [A:Q|R|B]
where collinear(a.from, a.to, A.from),
  between(a.to, a.from, A.from),
  collinear(A.from, A.to, a.to),
  between(A.to, A.from, a.to)
story "Coulomb theme: After Key 1.{K}!{threat_clause},
  Black defense 1...{a} advances toward White's
  {A.role_name} on {A.from}, met by 2.{A}#."
```

### Focal theme
**Enum**: `NamedTheme::FocalTheme` · *Alias*: Brennpunktthema

A Black line-piece on a focal square guards two focal squares along different vectors; moving along different rays abandons guard of the other focal square.

```thema
def [a:Q|R|B b:Q|R|B]
key [A B]
where same_piece(a, b), a.dir != b.dir, A.to != B.to,
  guards(a.from, A.to), guards(a.from, B.to),
  !collinear(a.from, A.to, B.to), a.unguards(A.to),
  b.unguards(B.to)
story "Focal theme (Brennpunktthema): Black's focal
  {a.role_name} on {a.from} cannot maintain simultaneous
  guard of {A.to} and {B.to} after 1.{K}!{threat_clause}:
  1...{a} 2.{A}# vs 1...{b} 2.{B}#."
```

### Pendulum theme
**Enum**: `NamedTheme::PendulumTheme` · *Alias*: Pendulum

A White line-piece moves in one direction from its origin square in a try and in the opposite direction along the same line in the key, changing mates.

```thema
^try Tr:Q|R|B [A B]
^key K:Q|R|B [C D]
where same_piece(Tr, K), collinear(Tr.from, Tr.to, K.to),
  between(Tr.from, Tr.to, K.to)
subsumes ChangedMate
story "Pendulum theme: White's {K.role_name} on {K.from}
  swings in opposite directions along the line
  between Try 1.{Tr}? (2.{A}#, 2.{B}#) and Key 1.{K}!
  (2.{C}#, 2.{D}#)."
```

### Bishop sacrifice
**Enum**: `NamedTheme::BishopSacrifice`

White actively sacrifices a Bishop on the key move.

```thema
def [a:x@K]
key K:B [A]
subsumes ActiveSacrifice
story "Bishop sacrifice: Key 1.{K}!{threat_clause}
  sacrifices a White Bishop on {K.to}, met
  by 1...{a} 2.{A}#."
```

### Knight sacrifice
**Enum**: `NamedTheme::KnightSacrifice`

White actively sacrifices a Knight on the key move.

```thema
def [a:x@K]
key K:N [A]
subsumes ActiveSacrifice
story "Knight sacrifice: Key 1.{K}!{threat_clause}
  sacrifices a White Knight on {K.to}, met
  by 1...{a} 2.{A}#."
```

### Double-sacrifice key
**Enum**: `NamedTheme::DoubleSacrificeKey`

The White key piece moves to a square where two different non-King Black pieces can capture it, yielding distinct checkmates.

```thema
def [a:!K:x@K b:!K:x@K]
key K [A B]
where a.from != b.from
subsumes SacrificialKey
story "Double-sacrifice key: Key 1.{K}!{threat_clause}
  offers the {K.role_name} on {K.to} to two Black
  capturers: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
def [a:!K:x@K b:!K:x@K]
key K (XY) [A B]
where a.from != b.from
with -match_threat_count
subsumes SacrificialKey
story "Double-sacrifice key: Key 1.{K}!{threat_clause}
  offers the {K.role_name} on {K.to} to two Black
  capturers: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Triple-sacrifice key
**Enum**: `NamedTheme::TripleSacrificeKey`

The White key piece moves to a square where at least three different Black pieces can capture it, yielding three distinct checkmates.

```thema
def [a:x@K b:x@K c:x@K]
key K [A B C]
where distinct(a.from, b.from, c.from)
subsumes DoubleSacrificeKey, MultipleCaptures
story "Triple-sacrifice key: Key 1.{K}!{threat_clause}
  offers the {K.role_name} on {K.to} to three
  Black capturers: 1...{a} 2.{A}#, 1...{b} 2.{B}#,
  1...{c} 2.{C}#."
```

### Royal sacrifice key
**Enum**: `NamedTheme::RoyalSacrificeKey`

The White key piece sacrifices itself on a square adjacent to the Black King so that the Black King itself captures it.

```thema
def [a:K:x@K]
key K [A]
subsumes ActiveSacrifice, FlightCapture
story "Royal sacrifice key: Key 1.{K}!{threat_clause}
  sacrifices the {K.role_name} directly to the Black King
  on {K.to}: 1...{a} 2.{A}#."
```

### Theme B
**Enum**: `NamedTheme::ThemeB` · *Alias*: Thema B

Two Black moves of a piece open a Black defensive line while self-blocking or closing another line, separating two White mates by the same piece.

```thema
key [A B]
where same_piece(a, b), a.to != b.to, same_piece(A, B),
  A.to != B.to, (a.opens_line() || b.opens_line()),
  (a.self_block || a.closes_line()),
  (b.self_block || b.closes_line())
subsumes LineOpening
story "Theme B: Key 1.{K}!{threat_clause}.
  Moves 1...{a} and 1...{b} open a Black line while
  closing/self-blocking to separate 2.{A}# and 2.{B}#."
```

### Theme H
**Enum**: `NamedTheme::ThemeH` · *Alias*: Thema H

Two tries by the same White piece are refuted by two different Black pieces moving onto the vacated departure square (Umnov refutation).

```thema
try Tr1 [! _]
try Tr2 [_ !]
key K [A B]
where same_piece(Tr1, Tr2), Tr1.to != Tr2.to,
  a.to == Tr1.from, b.to == Tr2.from, a.from != b.from
subsumes DefencesOnSameSquare, Laitinen
story "Theme H: Tries 1.{Tr1}? and 1.{Tr2}? are refuted on
  the vacated square {Tr1.from} by 1...{a}! and 1...{b}!;
  Key 1.{K}! answers with 2.{A}# and 2.{B}#."
```

### Bottacchi
**Enum**: `NamedTheme::Bottacchi` · *Alias*: Bottacchi theme

Moves of a Black Knight and a Black Bishop self-block or interfere on squares around the Black King, forcing four distinct White mates.

```thema
def [a:N b:N c:B d:B]
key [A B C D]
where same_piece(a, b), same_piece(c, d),
  (a.self_block || b.self_block || c.self_block
    || d.self_block)
story "Bottacchi: Key 1.{K}!{threat_clause}. Black
  Knight (1...{a}, 1...{b}) and Bishop (1...{c}, 1...{d})
  defenses allow 2.{A}#, 2.{B}#, 2.{C}#, and 2.{D}#."
```

### Pseudo Umnov 2
**Enum**: `NamedTheme::PseudoUmnov2`

In virtual play (set or try), a Black defense vacates a square for White's Umnov mate, and after the key the mate after that defense changes.

```thema
vir [A@a.from]
key [B]
where B.to != a.from
subsumes ChangedMate
story "Pseudo Umnov 2: Virtual Umnov mate 1...{a} 2.{A}#
  on {a.from} changes after Key 1.{K}! to 1...{a} 2.{B}#."
```

### Phoenix
**Enum**: `NamedTheme::Phoenix` · *Alias*: Phoenix theme

The key sacrifices a White piece (Q, R, B, or N), and when Black captures that piece, a White pawn promotes to the exact same piece type (rising from the ashes).

```thema
def [a:x@K]
key K:Q|R|B|N [A:P:=]
where A.promotion == K.role
subsumes ActiveSacrifice, PromotionKey
story "Phoenix: Key 1.{K}! sacrifices the White {K.role}
  on {K.to}; after 1...{a}, a White pawn promotes to a new
  {A.promotion} with 2.{A}#."
```

### Magee theme
**Enum**: `NamedTheme::Magee` · *Alias*: Magee

Four Black pawn self-block defenses around the Black King allow four different White pieces to deliver mate.

```thema
def [a:P b:P c:P d:P]
key [A B C D]
where (a, b, c, d).self_block,
  distinct(A.from, B.from, C.from, D.from)
subsumes Barulin, SelfBlock
story "Magee theme: Key 1.{K}!{threat_clause}.
  Four Black pawn self-blocks (1...{a}, 1...{b}, 1...{c},
  1...{d}) allow four different White pieces to mate:
  2.{A}#, 2.{B}#, 2.{C}#, 2.{D}#."
```

### Siegfried
**Enum**: `NamedTheme::Siegfried` · *Alias*: Siegfried theme

Tries by a White piece fail to Black slider focal defenses; a waiting move by that White piece solves by deflecting the focal Black slider.

```thema
def [a:Q|R|B b:Q|R|B]
try Tr1 [! _]
try Tr2 [_ !]
key K () [A B]
where same_piece(Tr1, Tr2, K), same_piece(a, b),
  a.to != b.to
subsumes FocalTheme
story "Siegfried: Tries 1.{Tr1}? (1...{a}!) and 1.{Tr2}?
  (1...{b}!) fail to the focal Black {a.role_name} until
  waiting Key 1.{K}! deflects it for 2.{A}# and 2.{B}#."
```

---

## 14. Stipulations, Key Types & Piece Economy

*Problem stipulations (Miniatures ≤ 7 pieces, Merediths ≤ 12 pieces, Aristocrat, Rex Solus) and key move classifications (Quiet key, Waiting key, Zugzwang).*

### Capture Key
**Enum**: `NamedTheme::CaptureKey`

The Key move captures an enemy piece.

```thema
key K:x
story "Capture key: Key 1.{K}!{threat_clause} begins with
  the capture of an enemy piece."
```

### Seeberger
**Enum**: `NamedTheme::Seeberger`

A piece is forced to a square where it interferes with another piece of the same color, causing zugzwang.

```thema
key [A]
where a.to == A.to, a.obstructs(A)
story "Seeberger interference: Key 1.{K}!{threat_clause}
  compels defense 1...{a} to obstruct a friendly line
  piece, conceding 2.{A}#."
```

### Miniature
**Enum**: `NamedTheme::Miniature`

A problem with at most 7 pieces in total on the board.

```thema
key K
where piece_count() <= 7
story "Miniature: Key 1.{K}!{threat_clause} solves
  a composition of pristine economy (≤7 pieces)."
```

### Meredith
**Enum**: `NamedTheme::Meredith`

A problem with 8 to 12 pieces in total on the board.

```thema
key K
where piece_count() >= 8, piece_count() <= 12
story "Meredith: Key 1.{K}!{threat_clause} solves
  an economical problem of 8 to 12 pieces."
```

### Zugzwang
**Enum**: `NamedTheme::Zugzwang`

Black is compelled to move in a position where any move worsens their defense, leading to checkmate.

```thema
key K [A]
where !K.check, K.threat_count == 0
story "Zugzwang: Key 1.{K}! creates complete zugzwang;
  Black's compelled move 1...{a} concedes 2.{A}#."
```

### Quiet key
**Enum**: `NamedTheme::QuietKey`

The key move is non-checking and non-capturing.

```thema
key K
where !K.check, !K.capture
story "Quiet key: Subtle non-checking, non-capturing key
  1.{K}!{threat_clause} weaves an inescapable mating net."
```

### Waiting key
**Enum**: `NamedTheme::WaitingKey` · *Alias*: Block key

The key move creates no direct threat, putting Black into zugzwang (waiting move).

```thema
key K [A]
where !K.check, K.threat_count == 0
story "Waiting key: White key 1.{K}! preserves the tension
  without a direct threat, waiting for Black's move
  1...{a} to concede 2.{A}#."
```

### Complete block
**Enum**: `NamedTheme::CompleteBlock` · *Alias*: Block

A block problem where all Black defenses in the diagram position already have set mates.

```thema
set [A*]
key [B*]
where set_play_complete()
with -match_mate_count
story "Complete block: All Black defenses are provided for
  in set play (1...{a} 2.{A}#); Key 1.{K}!{threat_clause}
  solves with 1...{a} 2.{B}#."
```

### Incomplete block
**Enum**: `NamedTheme::IncompleteBlock`

A waiting-move problem where some but not all Black defenses have set mates before the key.

```thema
set [A -]
key K [_ C]
where !set_play_complete(), unprovided_count() > 0,
  set_mate_count() > 0, K.threat_count == 0
subsumes AddedPlay
story "Incomplete block: Some defenses are provided in set
  play, while remaining play is completed by waiting
  Key 1.{K}!: 1...{b} 2.{C}#."
```

### Mutate
**Enum**: `NamedTheme::Mutate` · *Alias*: Block Threat

A complete block problem in which at least one defense is answered by a changed mate while maintaining no threat.

```thema
set [A]
key [B]
where K.threat_count == 0, set_play_complete()
subsumes ChangedPlay
story "Mutate: Complete waiting block in set play;
  Key 1.{K}! changes the mating replies: 1...{a} 2.{A}#
  -> 2.{B}#."
```

### Block
**Enum**: `NamedTheme::Block`

White key creates no direct threat, relying on Black's zugzwang to deliver checkmate on any reply.

```thema
key K
where false
story "Block: White key 1.{K}! creates no direct threat,
  relying on zugzwang to deliver checkmate on any reply."
```

### Le Lionnais
**Enum**: `NamedTheme::LeLionnais`

White King waiting key succeeds while at least three other White King tries fail.

```thema
try T1:K
try T2:K
try T3:K
key K:K (-)
where distinct(T1.to, T2.to, T3.to, K.to)
with -no_threats_few_replies -no_threats_sparse_mates
  -single_refutation -refutation_is_check
story "Le Lionnais: White King tries 1.{T1}?, 1.{T2}?,
  and 1.{T3}? fail, leaving waiting Key 1.{K}! as
  the unique Royal choice."
```

### Rex solus
**Enum**: `NamedTheme::RexSolus` · *Alias*: Rex Solus

Black has only the King and no other pieces on the board.

```thema
key K
where black_piece_count() == 1
story "Rex solus: Key 1.{K}!{threat_clause} skillfully
  outmaneuvers the lone Black King."
```

### Aristocrat
**Enum**: `NamedTheme::Aristocrat`

A chess problem containing no pawns.

```thema
key K
where pawn_count() == 0
story "Aristocrat: Key 1.{K}!{threat_clause} solves
  a composition without pawns."
```

### Tanagra
**Enum**: `NamedTheme::Tanagra`

A miniature problem with 5 or fewer pieces in total on the board.

```thema
key K
where piece_count() <= 5
subsumes Miniature
story "Tanagra: Key 1.{K}!{threat_clause} solves
  a miniature of utmost economy (≤5 pieces)."
```

### Duel
**Enum**: `NamedTheme::Duel`

A confrontation in which only one White piece and one Black piece move across all variations.

```thema
key K [A* B* C*]
where same_piece(a, b, c), same_piece(A, B, C),
  (distinct(A.to, B.to, C.to) || ((A, B, C).fires_battery
    && A != B)),
  (K.threat_count > 0 || !A.slider)
with -match_mate_count
story "Duel: Key 1.{K}!{threat_clause} sparks a duel
  between two pieces across variations: 1...{a} 2.{A}#,
  1...{b} 2.{B}#, 1...{c} 2.{C}#."
---
try Tr1 [! _ _]
try Tr2 [_ ! _]
try Tr3 [_ _ !]
where same_piece(Tr1, Tr2, Tr3), same_piece(a, b, c)
with -skip_no_threats_few_replies
  -skip_no_threats_sparse_mates -match_threat_count
story "Duel: White's {Tr1.role_name} and Black's
  {a.role_name} engage in a duel across tries 1.{Tr1}?
  (1...{a}!), 1.{Tr2}? (1...{b}!), and 1.{Tr3}?
  (1...{c}!)."
```

### Herlin
**Enum**: `NamedTheme::Herlin` · *Alias*: Herlin counter clearance

Mutual head-on line duel between a Black slider and a White slider: Black moves toward the White piece and is captured by it (a -> B@a), or captures the White piece and is recaptured by a supporting White piece (b:x@B.from -> A@b).

```thema
def [a:!x b:x@B.from]
key [B:x@a A:x@b]
where same_piece(a, b), a.slider, B.slider,
  collinear(a.from, a.to, B.from),
  between(a.to, a.from, B.from)
story "Herlin counter-clearance:
  After Key 1.{K}!{threat_clause}, the Black {a.role_name}
  on {a.from} and White {B.role_name} on {B.from}
  engage in a head-on line duel: 1...{a} allows 2.{B}#,
  while 1...{b} allows recapture 2.{A}#."
```

### Knight duel
**Enum**: `NamedTheme::KnightDuel`

White and Black Knights duel: when a Black Knight moves to two distinct squares, a White Knight captures it on both squares or mates on its vacated square.

```thema
def [a:N b:N]
key [A:N@a B:N@b]
where same_piece(a, b), same_piece(A, B), a.to != b.to
subsumes Umnov
story "Knight duel: After Key 1.{K}!{threat_clause},
  White's Knight on {A.from} duels Black's Knight
  on {a.from}: 1...{a} 2.{A}# and 1...{b} 2.{B}#."
---
def [a:N b:N]
key [A:N@a.from B:N@b]
where same_piece(a, b), A.from != B.from, a.to != b.to
subsumes Umnov
story "Knight duel: After Key 1.{K}!{threat_clause},
  White's Knights duel Black's Knight on {a.from}:
  1...{a} 2.{A}# (occupying {a.from}) and 1...{b} 2.{B}#
  (capturing on {b.to})."
---
def [a:N b:N]
key [A:N@a.from B:N@b.from]
where a.from != b.from, same_piece(A, B)
subsumes Umnov
story "Knight duel: After Key 1.{K}!{threat_clause},
  White's Knight on {A.from} duels Black's Knights
  on {a.from} and {b.from}: 1...{a} 2.{A}# and
  1...{b} 2.{B}#."
```

### Bishop duel
**Enum**: `NamedTheme::BishopDuel`

A Black Bishop and a White Bishop duel along the exact same diagonal in at least two variations.

```thema
def [a:B b:B]
key [A:B B:B]
where same_piece(a, b), same_piece(A, B), a.to != b.to,
  A.to != B.to, collinear(a.from, a.to, A.from),
  collinear(a.from, A.from, A.to)
story "Bishop duel: After Key 1.{K}!{threat_clause},
  White's Bishop on {A.from} and Black's Bishop
  on {a.from} duel along the same diagonal:
  1...{a} 2.{A}# and 1...{b} 2.{B}#."
```

### Sackmann
**Enum**: `NamedTheme::Sackmann` · *Alias*: Sackmann theme

A waiting key provokes a Black check that is answered by the key piece moving along a pin line or interposing.

```thema
def [a:+ b]
key K () [A B]
where A.from == K.to
subsumes ProvokedCheck
story "Sackmann: Waiting Key 1.{K}! provokes check
  1...{a}, answered by 2.{A}#, alongside 1...{b} 2.{B}#."
```

### Larsen theme
**Enum**: `NamedTheme::LarsenTheme`

A capture key changes the pin status and provokes a Black pawn/piece check whose vacated departure square is occupied by White's cross-check mate.

```thema
def [a:+]
key K:x [A@a.from]
where !A.capture
subsumes CaptureKey, PseudoUmnov1
story "Larsen theme: Capture Key 1.{K}!{threat_clause}
  provokes check 1...{a}, answered by Umnov cross-check
  2.{A}# on {a.from}."
```

### Szöghy 1
**Enum**: `NamedTheme::Szoghy1`

After a waiting key, a Black checking defense vacates a square that White's front battery piece occupies to deliver discovered cross-check mate.

```thema
def [a:+]
key K () [A@a.from]
where A.fires_battery
subsumes BatteryMate, BatteryPlay, PseudoUmnov1
story "Szöghy 1: Waiting Key 1.{K}! allows check 1...{a},
  vacating {a.from} for battery cross-check 2.{A}#."
```

### Szöghy 3
**Enum**: `NamedTheme::Szoghy3`

In a mutate (waiting key with set play), two pawn promotion mates are reciprocally exchanged or changed against Black checks and defenses.

```thema
vir [A:P:= B:P:=]
key K () [B A]
where A.promotion != B.promotion
subsumes PromotionKey, ReciprocalChange
story "Szöghy 3: Waiting Key 1.{K}! reciprocally exchanges
  promotion mates 2.{A}# and 2.{B}# against 1...{a}
  and 1...{b}."
```

### Pedersen theme
**Enum**: `NamedTheme::Pedersen` · *Alias*: Pedersen

White Knight wheel tries into zugzwang are refuted by correction moves of a Black Bishop or Rook along a line.

```thema
def [a:B|R b:B|R]
try Tr1:N () [A !]
try Tr2:N () [_ !]
key K:N [C D]
where same_piece(Tr1, Tr2, K), same_piece(a, b),
  a.to != b.to
subsumes ChangedMate
story "Pedersen theme: Knight tries 1.{Tr1}? and
  1.{Tr2}? fail to Black {b.role} correction 1...{b}!,
  solved by Knight Key 1.{K}!."
```

### Römpp mates
**Enum**: `NamedTheme::RomppMates` · *Alias*: Rompp mates

A sacrificial ambush key into zugzwang decoys two Black sliders to capture the key piece, allowing two White battery pieces to deliver discovered mates.

```thema
def [a:R:x@K b:B:x@K]
key K () [A B]
where A.fires_battery, B.fires_battery
subsumes BatteryMate, BatteryPlay, DoubleSacrificeKey
story "Römpp mates: Waiting sacrificial Key 1.{K}! decoys
  1...{a} and 1...{b} to {K.to}, firing battery mates
  2.{A}# and 2.{B}#."
```

### Kindergarten
**Enum**: `NamedTheme::Kindergarten`

A chess problem in which the only pieces on the board are Kings and Pawns.

```thema
key K
where piece_count() == pawn_count() + 2
story "Kindergarten: Key 1.{K}!{threat_clause} solves
  a Kings-and-Pawns composition."
```

### Schiegl
**Enum**: `NamedTheme::Schiegl` · *Alias*: Schiegl theme

A promotion key into zugzwang is followed by Black Knight defenses that allow multiple Royal battery mates by the White King.

```thema
def [a:N b:N]
key K:P:= () [A:K B:K]
where A.fires_battery, B.fires_battery, A.to != B.to
subsumes PromotionKey, RoyalBattery
story "Schiegl: Promotion waiting Key 1.{K}! answers Black
  Knight moves 1...{a} and 1...{b} with Royal battery
  mates 2.{A}# and 2.{B}#."
```

### Perpetuum mobile
**Enum**: `NamedTheme::PerpetuumMobile`

A waiting key by a White slider against four Black King star-flights is followed by that same slider delivering all checkmates.

```thema
def [a:K b:K c:K d:K]
key K:B|R|Q () [A B C D]
where distinct(a.to, b.to, c.to, d.to), A.from == K.to,
  B.from == K.to, C.from == K.to, D.from == K.to
subsumes RadialFlights
story "Perpetuum mobile: Waiting slider Key 1.{K}! answers
  all four King flights (1...{a}, 1...{b}, 1...{c},
  1...{d}) with moves of the key piece."
```

### Hertzsprung material
**Enum**: `NamedTheme::HertzsprungMaterial`

A chess problem in which White's force consists solely of King, Queen, and two Rooks (K + Q + 2R).

```thema
key K
where white_piece_count() == 4,
  white_piece_count('Q') == 1, white_piece_count('R') == 2
story "Hertzsprung material: Key 1.{K}!{threat_clause}
  solves with White force consisting solely of King,
  Queen, and two Rooks."
```

### Kniest
**Enum**: `NamedTheme::Kniest` · *Alias*: Kniest theme

A capture key that both gives and takes a flight square is captured on K.to by at least three Black pieces (including the Black King), producing three distinct mates.

```thema
def [a:x@K b:x@K c:K:x@K]
key K:x [A B C]
where K.flights_given >= 1, K.flights_taken >= 1,
  a.from != b.from
subsumes CaptureKey, DoubleSacrificeKey,
  FlightGivingAndTakingKey, RoyalSacrificeKey
story "Kniest: Give-and-take capture Key
  1.{K}!{threat_clause} on {K.to} is captured by 1...{a}
  (2.{A}#), 1...{b} (2.{B}#), and King 1...{c} (2.{C}#)."
```

### Velikij
**Enum**: `NamedTheme::Velikij` · *Alias*: Veliky theme

Three tries by the White Queen along a line are each refuted by a Black Bishop/slider shadowing her on a parallel line (Opposition), before the Queen moves to the far end of the line into zugzwang.

```thema
def [a:B|R|Q b:B|R|Q c:B|R|Q]
try Tr1:Q [! _ _]
try Tr2:Q [_ ! _]
try Tr3:Q [_ _ !]
key K:Q () [A B C]
where same_piece(Tr1, Tr2, Tr3, K), same_piece(a, b, c),
  distinct(a.to, b.to, c.to)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "Velikij: Queen tries 1.{Tr1}? (1...{a}!), 1.{Tr2}?
  (1...{b}!), and 1.{Tr3}? (1...{c}!) are parried by
  Black's {a.role} until waiting Queen Key 1.{K}! solves."
```

### Monreal-Michel theme
**Enum**: `NamedTheme::MonrealMichel`

A capture key threatens capture of a Black Knight, whose random move, correction move, and checking capture allow three distinct mates by a White battery.

```thema
def [a:N b:N c:N:+]
key K:x (T) [A B C]
where same_piece(a, b, c), T.to == a.from,
  distinct(a.to, b.to, c.to),
  (A.fires_battery || B.fires_battery || C.fires_battery)
subsumes BatteryMate, BatteryPlay, CaptureKey,
  ProvokedCheck
story "Monreal-Michel theme: Capture Key 1.{K}! threatens
  2.{T}# on {a.from}; Knight moves 1...{a}, 1...{b}, and
  1...{c} allow battery mates 2.{A}#, 2.{B}#, and 2.{C}#."
```

### Salamanca theme
**Enum**: `NamedTheme::Salamanca` · *Alias*: Salamanca

A pawn capture key sacrifices the pawn on a square where Black's capture self-pins in a half-pin (Zilahi + half-pin), while the other half-pinned piece's defense allows the key pawn to advance for mate.

```thema
def [a:x@K b]
key K:P:x [A:P B:P]
where B.from == K.to, A.from != K.to,
  (a.self_pins_for(A) || b.self_pins_for(B))
subsumes ActiveSacrifice, CaptureKey, SelfPin
story "Salamanca theme: Pawn capture
  Key 1.{K}!{threat_clause} sacrifices on {K.to} (1...{a}
  2.{A}#) and advances on 1...{b} with 2.{B}#."
```

### Monkey theme
**Enum**: `NamedTheme::Monkey`

Tries by two White Rooks and two White Bishops (White Organ Pipes) moving to the same rank or file fail to Black pawn defenses before a quiet key solves.

```thema
try Tr1:B [! _]
try Tr2:R [_ !]
try Tr3:R [_ !]
try Tr4:B [_ !]
key K [A B]
where distinct(Tr1.from, Tr2.from, Tr3.from, Tr4.from),
  same(Tr1.to.rank, Tr2.to.rank, Tr3.to.rank, Tr4.to.rank)
with -refutation_is_check -flight_from_check
  -capture_try_piece -match_threat_count -match_mate_count
  -single_refutation -sparse_mates -few_replies
story "Monkey theme: White Organ-pipe tries 1.{Tr1}?,
  1.{Tr2}?, 1.{Tr3}?, and 1.{Tr4}? fail before quiet
  Key 1.{K}! solves."
```

---