The existing chess variants (CVs) use an enormous wide of different
concepts in their rules. Some of those new rules have a special feature, they can be used
in other variants, creating new games. A simple and good example is the pass rule: *A
player may pass his turn*. If you apply this rule to FIDE chess, you get a different
game, *Passing Chess* (or whatever...). I will call to this kind of rules, *mutators*.

What I want is to start a discussion about this concept, namely:

- What makes a certain rule a Mutator?
- Can mutators be applied to any game, or just to some set of CVs?
- How mutators interact with each other?
- Is the mutator concept flexible enough? If not, how can it be expanded?
- Is a mutator list useful to the CV community?

Definition: AmutatorM is a well-defined and reasonable concept that applied at least to one game G, produces a new game, denoted G[M].

Remark: A game G with mutator M, that is G[M] is, by definition, a new game. So we can apply other mutator M' on it to produce another new game denoted by G[M][M'].

I inserted the *reasonable* word in the mutator definition, to
avoid questionable mutators like rule __8th-yellow__: "The game must be played on
the 8th floor of a yellow building". I trust your common sense :-)

Even so, this is a not a strict definition, since I didn't define what a game is (a rather complex issue). To avoid this problem (since we will deal just with CVs), I use the next definition:

Definition: Let's denote "FIDE Chess" as game FIDE. Achess variantC is the result of applying N mutators, M1, M2, ..., Mn to FIDE, that is, C = FIDE[M1][M2]...[Mn].

Remark: A consequence is that every CV can be defined in terms of Mutators.

Example: Assume the Pass rule as a mutator. So, *Passing Chess*
is defined by FIDE[Pass].

What if we use more than one mutator in a game? Can we use the same mutator twice? It depends, of course...

Some initial notation:

**iff**means "if and only if"**x|y**means a choice between x or y.**set**means the typical mathematical set with zero or more elements, e.g. {1,2,3} or {}**sequence**means a deterministic sequence of numbers, e.g., {1,2,3,...} or {1,3,5,7,...}**rel-op**means one of the relational operators, i.e., <, >, =, <> (not equal), >=, <=- A game is made of
**turns**, and each turn has a set of**moves**for each player.

Now for some concepts:

- A mutator M is
**applicable**to game G iff G[M] is a game. - A mutator M is
**idempotent**in game G iff G[M] = G[M][M] - Mutators M and M' are
**commutative**in game G iff G[M][M'] = G[M'][M] - Mutator M is
**atomic**iff there is no mutators M' and M'' and a game G such that G[M] = G[M'][M'']. Otherwise M is**composite**. - Mutator M is
**parameterized**iff it needs one or more arguments to define it properly. It is denoted by M(param1, ..., paramN). - Given a game G and mutators M and M', if G[M][M'] and G[M'][M] are not
games, then M and M' are
**incompatible**towards G. Otherwise they are**compatible**towards G.

Assume the following mutators:

- NIL :
*changes nothing (perhaps this is not a mutator, because people may argue that it is not a reasonable rule).* - Pass :
*A player may pass is move.* - Unroyal:
*There is no longer any royal piece (no check, no mate and no castling)*. - Royal(set):
*All pieces in set become royal*. - Take-All :
*A player wins if he captures all unroyal opponent pieces.* - Move-Opponent :
*The player can move the opponent pieces.* - Regicide :
*Removes all royal pieces from the board*. - Progressive(sequence):
*The players have increasing moves for each move, given by sequence parameter.* - Stop-Turn
*If a player checks in the middle of his move, he must pass.* - Bad-Advice :
*A player offers for each move, two possible options to the opponent, who advises the player which to play*. - Reuse(same|other) :
*A player can reuse opponent captured pieces and drop them on his side (like in Shogi)**in the same board, or in other board*. - Assault(2|4) :
*Two games are played simultaneous with color reversed boards, by 2 or 4 players. Wins who finish first*.

Examples:

- Regicide is not applicable to FIDE (there is no winning condition). However, it is applicable to FIDE[Take-All]
- Pass is idempotent in FIDE, since FIDE[Pass] = FIDE[Pass][Pass]
- Bad-Advice is not idempotent in FIDE, since FIDE[Bad-Advice] is not equal to FIDE[Bad-Advice][Bad-Advice] (in this 2nd game, each player should offer 4 possible moves).
- Pass and Take-All are commutative in FIDE, since FIDE[Take-All][Pass] = FIDE[Take-All][Pass]
- Pass is an atomic mutator (at least, I think it is)
- Progressive and Assault are parameterized.
- FIDE[Progressive(1,2,3,4...)][Stop-Turn] = Scottish Progressive Chess.
- FIDE[Progressive(1,1,2,2,3,3,...)][Stop-Turn] = Slow Progressive Chess.
- FIDE[Progressive(1,2,2,2...)][Stop-Turn] = Marsellais Chess.
- FIDE[Progressive(1,2,3,4...)][Move-Opponent] = Progressive Orthodox Chess.

- Regicide and NIL are incompatible towards FIDE.
- Mutator [Bughouse] is composite since it is defined by [Reuse(other)][Assault(4)]

Here are some other mutators (only a few of them are mine, the others were taken from various sources). Some mutators would need more explanations to remove ambiguities, but the main idea is there.

- Misere :
*The player wins if it looses the original game*. - Must-Capture :
*Captures are compulsory*. - Must-Move :
*Moves are compulsory*. - No-Capture(set) :
*Pieces may not be captured at turns included in set*. - No-Move(set):
*Pieces may not be moved at turns included in set*. - Limit(N) :
*The game has a maximum of N turns*. - Stalemate(win|loss) :
*A stalemate is a loss or a win*. - Swap :
*A piece may swap its position with some other within its capturing or moving range*. - Ko :
*A move is not legal if it repeats the board position of the last turn*. - Strong-Ko :
*A move is not legal if it repeats any past board position*. - Kriegspiel :
*The player cannot see the opponent pieces, but he can repeat the move if the last one he tried was illegal*. - Exhaustion(turn|game) :
*All pieces should be moved, in a turn or in the entire game, until any piece can be moved again*. - Points :
*At the end of game, the player with more points wins**(note: this should be used with other Mutators, like next one)*. - Domination(set) :
*For each turn, the last player that occupied a square included in set, gains 1 point*. - Optional-Side(N) :
*After the Nth turn, the 2nd player can choose to switch sides rather than respond.* - Switch(N) :
*At each set of N turns, players switch sides*. - Handicap(remove-set,insert-set) :
*The pieces in remove-set (insert-set) are removed (inserted) from the board before the game starts*. - Conditional(set) :
*Each move may have a "if condition then ..." prefix attach to it. All legal conditions belongs to set*. - Whim :
*The original game turns Misere. This may be invoked only once in the game (not once per player)*. - Neighbors(left|right|opposite,low|high):
*A player win iff the player to his direction (left, right or opposite) has the lowest or highest score at the end of the game*. - Atomic :
*Each piece adjacent to a capture, friend or foe, is removed from the board*. - Nuclear :
*Each piece adjacent to a capture, friend or foe, is removed from the board (except the capturing piece)*. - Inertial :
*The last moved piece will continue to move on the following turns, if possible.* - Momentum :
*Same as Inertial, but the player can also move a new piece, or stop one with momentum*. - Rotational(clockwise|cclockwise,N) :
*The board rotates 90 degrees (counter)clockwise every N turns.* - Protean :
*Each unroyal piece takes on the powers of movement of whatever piece it captures*. - Morph :
*Each unroyal piece becomes whatever piece it captures*. - Magnetic :
*Same color repels, different color attracts in rookwise**way*. - Diplomatic :
*Moves are done at the same time, and just if they do not conflict with each other*. - Reserve(set) :
*Each player has the pieces in set that can be dropped one per turn at any turn*. - Save-Turn(N) :
*A player can pass and save his move. After saving N moves, he can make a double move*.

Fell free to send me more!

Let's imagine the following CV: The game is equal to FIDE chess until
turn 40, then it behaves like Misere Chess. How to do it? This could be done only with
mutators parameterized with other mutators (see next section). Other way is to insert a
new notation called prefixes. A Prefix is a condition that is attached to one or more
mutators. A mutator only works if its prefix condition is true, otherwise it behaves like
mutator NIL, i.e., it changes nothing. A prefix P of mutator M in game G is denoted by G**::**P[M]**::**

List of Prefixes:

- turn rel-op N - works if "actual turn rel-op N" result is true.
- board rel-op N - works on boards where "boards rel-op N".
- player(s) - works just for specified player(s).
- pieces in set - works just for pieces included in set. Pieces may be defined by type (e.g., Q), by color (e.g., wQ) or by starting position (e.g., Qd1).

It is also possible to combine prefixes using the logical operators,
like **and**, **or**, **not**, ...

Examples:

- FIDE
**::**turn>40[Misere]**::**- The first example of this section. - [Bughouse]
**::**board=1[Atomic]**::**- Bughouse, but the 1st board has an atomic mutator. - FIDE
**::**white[Take-All]**::**- The white player can**also**win by capturing all unroyal black pieces. Black plays as usual. - FIDE
**::**black[Unroyal]**:: ::**white[Take-All]**::**- The white player can**only**win if he captures all black pieces. Black plays with no royal piece. - FIDE[Handicap({a8,h8},{})]
**::**white[Limit(35)][Stalemate(loss)]**:: -**Black starts without his rooks, but white just has 35 moves to win, otherwise it looses. - FIDE
**::**pieces in {N,wQ,bR,Pa2}[Protean]**:: -**Just like FIDE, but there are the special Protean pieces: The Knights, the white Queen, the black Rooks and the Pawn at square a2.

High-order mutators are mutators that receive one or more mutators as parameters.

Instead of using prefixes, the job can be done using high order mutator *Apply*,
which syntax is [Apply(mutators, condition)] where the mutators are only applied if
condition is true. The example FIDE**::**turn>40[Misere]**::
**becomes FIDE[Apply([Misere],turn>40)].

Other high-order mutators:

- Remove(mutators) : the rules defined by mutators are removed from the game.
- Inverse(mutator) : returns the inverse of mutator, if it exists.
- Complement(mutator) : the illegal moves turn legal, and vice versa.
- Twice(mutator) : apply the mutator twice
- Limit(mutator) : apply mutator repeatedly until fixed-point (limit) is reached
- Compose(mutators) : compose two mutators. Mostly useful in combination with other high-order mutators.

Examples:

- FIDE[Remove([En-Passant])], returns a CV just like FIDE but without the en-passant rule.
- Inverse([Switch(3)]) :
*At each set of 3 turns, players do not switch sides*,*switching otherwise*. - Complement([Swap]) :
*A piece may swap its position with some other*.**not in**its capturing or moving range

Of course, if there are some problems defining what makes a mutator reasonable, there is an extra problem with high-order mutators and that is an interpretation one (e.g., what is the inverse of mutator X?)

Claude Chaunier, Torben Mogensen, Bill Taylor

**written by Joćo Pedro Neto**

Written by Joćo Pedro Neto.

WWW page created: February 8, 2000.