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: A mutator M is a welldefined 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 8thyellow: "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. A chess variant C 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"  
xy 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,...}  
relop 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.  
TakeAll : A player wins if he captures all unroyal opponent pieces.  
MoveOpponent : 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.  
StopTurn : If a player checks in the middle of his move, he must pass.  
BadAdvice : A player offers for each move, two possible options to the opponent, who advises the player which to play.  
Reuse(sameother) : 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(24) : 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[TakeAll]  
Pass is idempotent in FIDE, since FIDE[Pass] = FIDE[Pass][Pass]  
BadAdvice is not idempotent in FIDE, since FIDE[BadAdvice] is not equal to FIDE[BadAdvice][BadAdvice] (in this 2nd game, each player should offer 4 possible moves).  
Pass and TakeAll are commutative in FIDE, since FIDE[TakeAll][Pass] = FIDE[TakeAll][Pass]  
Pass is an atomic mutator (at least, I think it is)  
Progressive and
Assault are parameterized.


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.  
MustCapture : Captures are compulsory.  
MustMove : Moves are compulsory.  
NoCapture(set) : Pieces may not be captured at turns included in set.  
NoMove(set): Pieces may not be moved at turns included in set.  
Limit(N) : The game has a maximum of N turns.  
Stalemate(winloss) : 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.  
StrongKo : 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(turngame) : 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.  
OptionalSide(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(removeset,insertset) : The pieces in removeset (insertset) 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(leftrightopposite,lowhigh): 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(clockwisecclockwise,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.  
SaveTurn(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!
[December 2000] Patrick Duff sent me an idea for a sacrifice mutator. The point is to give the player, the choice to play a move with the opponent's pieces. This can be very interesting in certain games, like in Duff's own invention, Sacrifice Reversi, where a play may indeed sacrifice some stones in order to get a better future position!
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 relop N  works if "actual turn relop N" result is true.  
board relop N  works on boards where "boards relop 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[TakeAll]::  The white player can also win by capturing all unroyal black pieces. Black plays as usual.  
FIDE::black[Unroyal]:: ::white[TakeAll]::  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. 
Highorder 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 highorder 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 fixedpoint (limit) is reached  
Compose(mutators) : compose two mutators. Mostly useful in combination with other highorder mutators. 
Examples:
FIDE[Remove([EnPassant])], returns a CV just like FIDE but without the enpassant 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 highorder mutators and that is an interpretation one (e.g., what is the inverse of mutator X?)
Claude Chaunier, Torben Mogensen, Bill Taylor