Some more ruminations on directional modifiers:

Betza notation has implied operators for combining modifiers and atoms, which contributes to its compactness. The operations can be joining or intersecting the sets of moves selected by the individual modifiers. E.g. an frW is a Wazir that moves forward OR left (2 moves; (f+r)W = fW + rW = fWrW). OTOH frF would mean a Ferz that moves(along the right-forward diagonal (1 move: (f*r)F), intersecting the set of moves of fF and rF.

So it is not obvious which operation is implied; this depends on the symmetry and orientation of the atom. For 'orthogonal 4-movers' such as W the f, b, l, r modifiers specify disjoint sets of one, so intersecting is pointless, and any combination of modifiers thus implies joining.

In the more general case of an oblique 8-mover these same modifiers specify pairs of moves, though. For historical reasons fsN means the forward moves of the wide Knight, and since s was defined as l+r, (so that fsN = flN + frN), frN would mean the upper-most of the r-pair. By rotation symmetry rvN would mean r(f+b)N = rfN + rbN, and rfN would specify the right member of the forward pair. So rfN and rfN each specify a single, different move. I.e. order of the modifiers matters here, and the combination neither implies joining or intersection: the f and r sets were disjoint. Basically fr and rf (etc.) are one symbol specifying a single direction on oblique atoms. (And in a counter-intuitive way; you would expect the major direction of the jump to be mentioned first!)

This poses a problem when you want to designate a Knight that has only the two forward and two right-most moves (f+r)N, as frN is already taken. Of course you can resort to repeating the atom, (f+r)N = fN + rN = fNrN. The alternative would be to introduce ff etc. as replacement for f in case there was ambiguity. So ffrrN would mean (ff+rr)N = ffN + rrN = fN + rN = fNrN. A bit ugly, and one letter extra. so I guess fNrN would be the preferred form. (And it is one letter shorter anyway.) So ff is not really needed. But fh is still a useful two-letter modifier that would be cumbersome to describe by other means (e.g. fhN = fNfsN).

For diagonal 4-movers, the fr and rf moves collapse into one. So the order no longer matters, and the f,b and r,l sets do intersect. OTOH f and b (as well as l and r) are each other's complement, so that v and s dont't mean anything.

If we want to describe continuation steps of bent leapers, the best way to do it seems in the coordinate system of the previous step. This best exploits symmetry of the moves. E.g. [FW] would view the W second step in 45-degree-rotated coordinates defined by the Ferz move, where it now appears a diagonal mover, and should use the corresponding system to describe its moves. That means that an inplied f ([FW] = [FfW]) now refers to two moves. The reulting two paths are indeed symmetry equivalent, and thus likely to occur together in typical variant pieces. (In fact they describe the Moa.)

By rotating coordinates we can get into situations where we have on-axis 8-movers, though. E.g. when both steps are Knight jumps, continuing in the same direction (as the Nightrider) would be pure f. It is as if orthogonal and diagonal moves are combined in the same atom (like the moves of the sqrt(50) leaper). On such an atom fr (equivalent to rf) is needed to describe the diagonal move, and thus cannot be used to imply joining of the f and r orthogonal move.

Note that in case of the N in the rotated coordinates the fl and fr moves are not perfectly symmetric, as the angle between neighboring oblique rays alternates between two values. In fact such symmetry-breaking can occur for all atom types. After a Knight jump both F and W would be tilted in the new coordinate system, and be neither diagonal nor orthogonal. But the tilting breaks the exact equivalence of moves that a purely diagonal mover suffers, so the simpler system for the orthogonal movers can be applied. It is always clear what f and b mean, however (most outward and inward). But l and r are more tricky, as they would depend on how you take the first N step. If you go from e1 to f3, then going to f4 would be f, and going to g3 would be r. But the symmetry-equivalent path to the latter (which regular pieces would also be able to take, so that it would be very annoying if you would have to specify it separately) would be e1-d3-c3, where d3-c3 is now lW, needing a different notation. Therefore I would propose to assume that the first step of the path was a move in the rf octant (from fW to frF, so to say). Then a n[NrW] would move along all symmetry-equivalent paths of e1-f3-g3, i.e. also e1-d3-c3, e1-f2-f3, e1-c2-c3. So basically the [XYZ...] notation implies [rfXfYfZ...] to specify a path starting in a unique direction, but then includes all 8-fold-symmetry-equivalent versions of that path, unless there are directional modifiers in front of the [XYZ...] (e.g. f[NW]).

I did some Google search, and I found some statements about Betza notation that are not reflected on this page.

• The Wikipedia claims that there is a modifier 't', for 'then'. A Griffin would be WtR. On this page it is described as [WR]. Has this notation superceded the t modifier? I have no reason to doubt that the mentioned t-modifier is genuine. Proposing 'then' as name for an operator is typical Betza thinking, and he mentions below that he was very careful to stay away form any puctuation stuff (actually mentioning brackets in that context!)
• The Wikipedia articles on large Shogi variants do use an extended Betza notation that accounts for the Lion by means of the symbols d and dh, where the double-move component of the Lion is written as dK, and that of the Falcon and Eagle as dhfW and dhfF, respectively.
• I found a comparatively recent PDF document by David Howe (on this website! http://chessvariants.org/dictionary/BexNotation.pdf ). He calls the extension proposed in there 'Bex Notation'. But Bex seems to conflict with what is described on this page. In particular, Bex notation uses the brackets for a completely different purpose, namely as 'exotica operator'. And it uses parentheses for the purpose brackets seem to be used here (except in a more general way, where you could group anything with them). I must admit I like notations that somehow parenthesize better than those with an internal t 'connection' operator, as the latter would raise questions about operator priority (i.e. does WtF2 mean [WF]2 or [WF2] ?), which you could not solve without any form of parenthesizing if you wanted to express the alternative meaning. The brackets used on this page seem to imply mrore than just grouping, though: they really alter the meaning of concatenating the atoms. Normally WF would mean K (= join the move sets). Within the brackets it means WtF (serial steps). I don't like that. In this respect Bex is good: parenthesis just for grouping are much more flexible, and using () will avoid confusion with the [] introduced here. You would need some explicit operation for serialization, however. Indeed Bex proposes the hyphen or double-hyphen for this, to replace the 't' modifier. I don't know if this is wise; For one, there seem to be more possibilities as 'general forward' or 'any direction', as the - and -- seem to indcate, respectively. (E.g oly sideways, as in the Tai-Shogi Hook Mover, which would follow an R move by an R perpendicular to it.) It seems more powerful to just have a single serialization operator, which defaults to 'the same general direction' (which I called forward in my proposal for describing continuation steps in coordinates rotated to fit the previous step that I made in the previous post). And then use directional modifiers to specify the non-default cases. The - seems more readable for this as the 't', because it is really a binary operator, while the other modifiers are all unary prefix operators. So it would be good if the serialization operator stands out from the others, which - certainly does. (The -- is a very bad choice, however, as in some fonts it can hardly be distinguished from the single -.) I would propose the simple concatenation to couple less tightly than the -, however. I.e. W-WF should mean (W-W)F = (nD)F, and not W-(WF). The latter seems rarely needed; normally the continuation step would have too many directions, such that you need directional modifiers to limit them, rather than that you would like to expand them by joining move sets of several atoms. In this case there is need for a directional modifier that indicates 'all directions'. Normally this would be implied when you use the unmodified Atom, but if in the context of a continuation step 'forward' is the default, it is suddenly needed. It seems better to use -a than to use --; the 'a' is on par with f, b, v, s etc., so it should be the same type of symbol. A piece that travels through a path of two King steps (an 'area mover', in Tenjiku Shogi terms) would be K-aK in my proposal, while K-K would be the same as K2. K-aK is not yet a move with Lion power, though, just a bent leaper. An extra modifier is needed to indicate something internal to the path can be captured, i.e. the move is that of a locust. How about using 'x' for this? This is after all the symbol for capture, while - is often used for non-capture moves. So they make a nice logical duo. KxaK would then be a two-step King move that can continue after capture on the first step. The prefixes m and c would just pertain to the normal capture at the end of the move. So fmFxF would be a checker: it makes two collinear Ferz steps, but only to empty squares (hence the m), and it must capture on the way. The Lion would be KDANKxaK. I don't see any need for the [xo] component proposed for the Lion's null-move capability in Bex; this could be written without any new symbols as K-bK: make a non-capture King step, and then make it back. There also seems no need for the d / dh modifiers. I don't like the Bex proposal to use y for royal. I think this letter should be reserved for bifurcators, somehow. Much better to use 'k' (as in 'King') for royal pieces. OTOH, an O atom for unconditional null moving (unlike the Lion's, which is dependent on the proximity of an empty square) seems a very good idea, as is the 'i' for initial move. I would like to have a better notation for hoppers / bifurcators. The g/p modifiers are much too limited in scope, as they assume no directional change on hopping. I would be nice to have a binary operator connecting two moves that indicated a hop should occur between them. Like cR+R for the Canon's capture move, and mRcR+R for the Canon. And Q+K for the Grasshopper. No need for p and g at all. And it would also be able to handle cases of a bifurcating hopper, like R+B, which would move to the platform as R, and then change direction to continue as B in the outward direction. (For + any other symbol or letter could be used, perhaps ^, or even h.) Similarly RyB could mean a bifurcator that changes direction just before it bumps into an obstacle. RxB would be the locust corresponding to the hopper.

Betzetera Notation

Sorry for turning this subject into a monologue. But everything seems to fall into place, which makes me confident to make a new proposal for extending Betza notation, very much in the spirit of the existing one: compact, elegant and powerful. It draws some inspiration from the Bex notation proposed by David Howe.

Then was then, but now...

Some places mention the modifier 't', as a binary operator for chaining moves. Like FtR: start like Ferz, then continue as Rook. (With the 'f' implied for chaining this describes the Griffon.) The later step is optional, however, you can always terminate at a t. (The Griffin can move as F!) This distinguishes it from the chaining operator '-' from Bex, where continuation is mandatory, and the whole move is blocked if the square is not empty. This proposal also embraces the '-' operator.

It proposes additional chaining operators as well, though. Apart for changing direction, chaining can be used to indicate a 'chaining' square the state of which has to be probed to decide about the move, or which might even change this state as a side effect of the move. The following such operators are proposed:

The operator d is needed for some Taikyoku sliders, which capture anything they jump over. The y can be used to describe colliding bifurcators, which basically are hoppers that hop one step early.

Some examples: Q+K is the Grasshopper: move as Q to an occupied square, and mandatory continue outward with a K step. No need for a 'g' modifier. mRcR+R is the Xiangqi Cannon. The mR is obvious, the R+R indicates moving as Rook to an occupied square, and from there continue as Rook in the outward direction. The c modifier prefix indicates this is only for capture, as usual. A bit longer than pR, perhaps, but much more flexible, as it allows describing directional change at the platform. RyB would be the Dimachaer, sliding as R until it collides with an obstacle, then continuing as B to make its move or capture there. W+WF+FD+DA+AN+NH+HG+GJ+JL+L would be the Equihopper (as the + operator couples more tightly than concatenation of atoms).

What's in a number?

Numbers indicate exponentiation, i.e. repeated application of the same operator. The implied operator is 't', for optional continuation. So W3 means WtWtW, which could be expanded to (W)(W-W)(W-W-W) = WnDnH. (The proposal involves allowing the use of parentheses for grouping or clarity, like in Bex.) Bex proposes to use W03 for indicating just the W-W-W component of this. Because we have more than just the t and - chaining operators here, this doesn't cut the cake, however. In the spirit of Betza notation, we use more general modifiers on the exponent.

In fact the prefixed 0 in Bex was a sort of non-obvious modifier prefix. But it is much clearer to just prefix the exponent with the operator whose repetitive application it orders. The default prefix would be t for backward compatibility. So W3 = Wt3 = WtWtW. But W-3 = W-W-W, and Wx3 = WxWxW, etc.

Chaining does not only imply the t operator; it also implies a directional modifier 'f' on the continuation. So F2 actually means FtfF. Note that the fF moves in this case refer to the 45-degree rotated coordinate system of the previous step, where 'f' is identified with 'most outward', and the Ferz looks like a Wazir. So fF implies only a single move in continuation, so that F2 describes a non-jumping Alfil, as in Betza notation. If we want to specify something else, e.g. a bent di-Ferz, moving as Dabbaba, we would have to use explicit directional modifiers: FtsF, specifying the second step is taken perpendicular to the first one. To globally apply such a modifier to all later factors of an exponentiation, we can apply it to the exponent. So Fts2 would by definition mean FtsF, and Nfr8 would mean upto 8 consecutive Knight steps, each step continuing just a bit right from straight ahead. But that is the Rose! No need for a special q operator anymore; it is all in the basics. Nr4 would similarly specify a circular Knight that returns to its origin in 4 steps.

Another proposal regarding numbers: The 0 (zero) can be used to indicate arbitrary repetition, as it would have no meaning in the literal interpretation. So W0 would indicate the Rook. This is an alternative for WW, as the latter becomes very troublesome with the rules that chaining operators have higher precedence than atom concatenation. You could for instance not use a DD move in a hopper description without using parentheses: (DD)+(DD). D0-D0 is OK, however, as exponentiation has higher precedence than chaining. I prefer this over using D*, as Bex does, because the 0 suggests more that you are dealing with an exponent than the * (which suggests a binary operator to those not used to regular expressions).

And there is more: Ft(lFtrF)0 = FtlFtrFtlFtrF... is the Crooked Bishop, with a more precise description of how crooked. You dont have to move in circles if you don't want to!

Note that the 0 indicates an arbitrary number of steps, not an infinite number. So it can safely be used with chaining operators that specify mandatory continuation (i.e. any other than t). E.g. W-0 would in itself already expand to (W)(W-W)(W-W-W)... = R, and thus happens to be the same as W0. (Well -0 = 0, right? ;-) ) But cWx0 (Bulldozer?) would expand to c(W)c(WxW)c(WxWxW)..., a piece that makes an arbitrary number of hit-and-run captures with mandatory continuation, and finally a capture (as specified by the C). So it can capture any number of consecutive enemy pieces. A Qd0 would make an arbitrary number of 'Qd...' steps to occupied squares, destroying anything in its path, friend or foe, until it ends with a Q normal capture or non-capture (Steamroller?). Note that the d operator (or any operator) can also be invoked on a final step, by adding a dummy O (oh) atom (also embrased from Bex) as final step. A BdO is a Bishop that must capture friend or foe, and then mandatorily 'continue' with a null move.

Some moves are more equal than others!

We also propose a new modifier on chained slider moves, namely 'e'. This means 'same length as the previous step'. This allows encoding of a lot of 'alien' capture modes. For instance, (orthogonal) rifle capture could be written as RxebR: move as Rook to make a capture, and mandatorily continue in the backward direction with an equally long Rook move. i.e. return to your square of origin after making a normal capture. Suddenly rifle capture doesn't seem so un-Chess-like anymore, once you allow hit-and-run captures with the x chaining operator!

The Ultima Withdrawer can be written as mQmKxbK-Q. I.e., non-capture as a Queen (mQ), or capture as King, and then mandatorily continue in the reversed direction (bK) by another King step (KxbK, a King rifle capture), and subsequently continue as slider in that reversed direction, where you cannot capture anything (by replacement) anymore (hence m(KxbK-Q)).

An Advancer can be written as mQK-QxbK: the interesting move start with a King step (to force minimally one step), mandatorily continues by sliding an arbitrary number of squares in the same direction to capture an opponent, and again mandatorily continue in the reversed direction for one step (bK), so that it ends up just 'in front' of the piece it captured. (No need to specify 'm' on it; the final square is guaranteed to be empty, as we just passed over it!) It would also be possible to specify 'long-range advancers', basically an intermediate between the Roccoco Advancer and rifle capture, capturing anything at the end of the ray it moves on (Spearman?). It would be mQtQxebQ: move like Q and either terminate at an empty square X (m!), or continue in the same direction an arbitrary distance to the first piece, which you capture, and then mandatorily move all the way back to X.

The Checker would be fmFxF, capture as F and mandatorily continue with a non-capture (as the m/c modifiers have lower precedence than chaining, and thus always apply to the whole chain, fm(FxF)), all this in the forward direction of the initial Ferz move only. But the Ultima Long Leaper can also be easily encoded: mQm(QxQ)-0, the capture move expanding to m(QxQ)m(QxQ-QxQ)m(QxQ-QxQ-QxQ)..., the '-' chaining after each QxQ ensuring that the move will be blocked if there isn't at least one empty square behind the hit-and-run victim, and the m prefix ensuring this for the last QxQ locust hop.

The linear stinging move of Chu-Shogi's Soaring Eagle would be f(FxvF), the x specifying mandatory capture with continuation of the first fF step, followed by a second step along the same line (forward or backward = v), which may or may not capture. It encompasses the rifle capture, double capture and locust capture. (But fFfA would still have to be specified separately.) The similar triple sting of the Tai-Shogi Lion Dog (which goes in all directions) would be (KxKxvK)((AD)xvK)(KxvK).

Based on an entirely different philosophy, I produced an alternative for my previous proposal. It would be nice if people could comment on which they like better. Where the previous extension was based on defining many different operators for chaining move steps into multi-leg moves, this new proposal retains only a single chaining operator, and puts the responsibility for describing the various conditions that must be met or things that should happen on the intermediate square to the description of the chained steps.

This seems to stay closer to the original Betza notation, and more compatible with David Howe's Bex proposal. For instance, because we are back to just one chaining operator, the trick of specifying an exact number of steps by a lading zero on the count can be embraced. I had to define a fair number of new move modalities in addition to mc, however, and not so many unused letters were left over. So I re-used the modifiers p, o and (perhaps) t in slightly different meanings. But because they can only be used in this new meaning as part of an early leg of a multi-leg move, this should not cause ambiguity with the old usage.

Betza notation 2.0

Move steps of the basic atoms

SINGLE MOVES        PAIRS OF MOVES             SETS OF FOUR MOVES

    lf rf          f f          lv rv          fh fh         lh rh
  fl     fr     fs     fs     l       r      fh     fh     lh     rh
  bl     br     bs     bs     l       r      bh     bh     lh     rh
    lb rb          b b          lv rv          bh bh         lh rh


      f                    v
    l + r                s + s
      b                    v


   fl  fr         f   f         l   r
     x              x             x
   bl  br         b   b         l   r


    f               v             v
 fl   fr         fs   fs       lv   rv
l   *   r       s   *   s     s   *   s
 bl   br         bs   bs       lv   rv
    b               v             v

Grouping

Parentheses can be used for grouping, but have no meaning by themselves. (W) is exactly the same as W.

Chaining

Atomic steps can be 'chained' into a single 'mult-leg' move. Actually W3 means (W)(W-fW)(W-fW-fW), where '-' is the chaining operator. The f means 'continuing forward', i.e. in the same direction, as directions are always measured relative to the previous leg. In the right-hand part of a chaining operator f is implied by default. To specify a bent trajectory, explicit directional prefixes are needed. Note that a bent chain can fork, and thus represent multiple moves.

Chaining implies the intermediate square should be empty, and the described move is considered blocked if it isn't. In other words, an m prefix is implied on every left-hand part of the chaining operator. Explicit use of modifiers for the move modality can override this, to create other conditions that have to be satisfied for the move to continue, or 'side effects'.

For example: a Checker is fmFfcF-mF, the forward fcF step to capture only allowed if the following (f)mF in the same direction to an empty square can also be made. The Xiangqi Horse is W-F: it can be blocked on the (m)W step, but if it isn't, it can continue to complete an N move. The Chinese Cannon is mRpR-cR: mR for the non-capture, and pR to bring it to an occupied square, from which it must continue in the same direction with an (f)cR to capture a foe. The Grasshopper, pQ-K, moves with pQ as a Queen to an occupied square, and changes stride there to a King step in the same direction (f)K to capture or non-capture. A Chu-Shogi Lion hit-and-run or double capture is cK-aK: first capture a neighboring piece with cK, then arbitrarily change direction for the aK step to possibly capture a second time.

Eruption, explosion and suicide

There is a special modifier x that specifies eruption. This means that at the start of the leg to which it applies the moving piece stays in place itself, but ejects a multitude of independent 'fragments', which will continue along the chain in every possible way simultaneously and independently. The fragments disappear when they reach the end of the chain, but when they block, it only affects themselves, not other fragments or the real piece that was left behind. For example mcB-xaK means the piece makes a Bishop move (mcB, move or capture) to square S and then erupts to emit fragments along an aK step, dispersing them in 8 directions, to capture what they find there (or silently evaporate). Thus all enemies surrounding square S will be captured, as in Tenjiku-Shogi Fire-Demon burns.

Suicide can be expressed with the aid of a null-move leg: dO suffixed behind the move. A kamikaze capture on a Bishop move would be cB-dO. This can be combined with eruption to indicate an explosion in which the piece is destroyed: So an Atomic Queen would be like mQcQ-xdO-acdK, exploding itself after capture with xdO, while the fragments move on to destroy friend and foe in all directions with acdK. [No method yet to exempt Pawn victims, though.]

Describing alien modes of capture

Unusual (= non-replacement) capture can be described by visiting the capture squares as part of a chain, but not staying there. Rifle capture can be cR-ebR, a Rook capture followed by an equally long move (ebR) in the reversed direction. The Roccoco Advancer would make a forward rifle capture from the (empty) square where it stops: mQ-cK-bK, which has the collinear rifle capture (f)cK-bK appended to the real move. Ultima Pincer-Pawn captures can be described with the aid of eruption: mR-xatD-bW. The emitted fragments move from the final square where the eruption takes place to orthogonal D-neighbors in every direction, to test if there is a friendly piece there (atD). From such a piece they bounce back to capture a pinced foe (bW), and evaporate.

Capture of the Ultima Withdrawer is cK-bK-mQ: capture an adjacent piece (cK), but only if you can then move in the opposite direction to overshoot your starting square with a non-capture Queen move. (b(m)K to get back to the starting square, and (f)mQ to make the real move of at least one step.) There is a catch, however: there might be nothing to capture, and then the Withdrawer must be able to move as Queen. This cannot be repaired by offerring an mQ move as a general alternative, because that would make the Withdrawer capture optional even when it is possible. Writing the first step as mtcK to allow it to traverse an empty square and hop over a friend does still fail at the board edge, where the detour to probe for a victim would go off board. The modifier o for allowing crossing of the board edge can cure this: cmtoK-bK-mQ.

Bifurcators and Catapults

Bifurcators are basically bent hoppers that hop over off-ray supports. By warping their trajectory it can be made to pass through the support again. The Dimachaer, which changes tack just before its initial leg hits an obstacle, would be R-pW-bW-bB, a 'rifle hop' pW-bW inserted into the trajectory to fix the deflection point, which for the 'hook mover' R-B could have been anywhere. Bifurcating after the hop would be pR-W-B, deflecting would be R-rpW-bW-rbB, etc. The usual mc modifiers can specify what it might do on the second leg.

Pieces that displace other pieces as side effect of their move are called catapults. These can be specified with the aid of the u operator. E.g. (cdW-bW-R-uW-bW)(moW-bW-R) would specify an orthogonal mover that combines Withdrawer-like capture (making the cdW-bW detour to pick off the friend or foe in its wake) with a detour to unload the captured piece just in front of where it stopped. The alternative move that doesn't drop anything first tests if there really is nothing to launch, by requiring the square behind it is empty or off-board.

Magnetic pieces? No problem! B-xaK-cdK-buK is a Bishop that attracts all pieces that are 2 squares away one square towards it. An even more compact way to write it would be B-xacdK02-buK, which combines the two King steps into one 'jumping King' step that does both the omni-directional eruption and the picking up of the pieces. Repellers? Just change it to B-xacdK-uK, which picks up the pieces on the first step, and unloads them on the next step without reversing direction.

Castling

Castling is another challenge, as it moves two pieces. But in fact it is just a sort of catapult move. One piece could be used to carry the other to its destination. E.g. a move irdiW04-buW02-bW on a Rook would sort of describe Q-side castling. The leading i would indicate it is an initial move, that can only be made when the Rook has not moved yet. The rdW04 specifies sliding to the King square (confirming the emptiness of the in-between squares), to destroy it there. That we say di in stead of just d means it can only destroy a virgin King. By default we carry along what we capture or destroy, and discard it at the end of the move, or when we capture something else. The second leg reverses direction, and unloads the King two squares further. That we use uW02 rather than uD can have consquences for passing through check. after unloading the King, the Rook doubles back again, and takes its place with a single W step.

Some nitpicking

directonality - Oblique moves come in 'chiral pairs', which behave different with respect to l and r. So rfN-rW (an overall A step) is not symmetry-equivalent to lfN-rW (an overall D step). This would make it impossible to combine all symmetry-equivalent moves to N-rW, and force us to write each move separately. This is prevented by not only expressing the directions of a later step in coordinates that rotated to fit the previous step, but also flipped (exchanging the role of l and r) to make the initial step (or the first overall step when the trajectory became chiral) aim just right of the nearest orthogonal. So lfN-rW would actually mean the mirror image of rfN-rW, and N-rW will specify an 8-fold symmetric piece with a multi-path move to the A squares.

distributivity - The chaining operator specifies a default direction f for its right-hand operand, and a default modality m for its left-hand operand. This leaves the modality of the last leg of a chain unspecified (defaulting to the normal mc), as well as the direction of the first leg (defaulting to a). Modifier prefixes applied to an entire chain, like vc(X-Y-Z), will refer to these unspecified items, i.e. vX-Y-cZ. Directional and modality modifiers thus behave differently!

Applied to a compound move set, modality modifiers apply to all moves of the set: c(XYZ) means cXcYcZ. It is in general not sensible (or meaningful) to apply directional modifiers to a compound move set: first combining the move sets just makes it harder to specify which of them you exactly mean, and the directional system is only defined to hadle sets of 4 or 8 moves. The possible exceptions are K and Q, which are convenient shortcuts. Their moves can be treated in the scheme for the non-degenerate 8-fold case. I.e. fK = fW, fsK = fF, etc. Note that for continuation legs in 45-degree rotated coordinates fK could also refer to a single F move.

exponentiation - A number behind an atom or a set of moves protected by parentheses means by default any number of the corresponding moves upto the specified value chained together. When the number starts with a zero digit, it means exactly that number of repetitions. i.e. (X-Y)03 means (X-Y)-(X-Y)-(X-Y) which by default means (mX-fY)-(mX-fY)-(mX-fY), which again defaults to m(mX-fY)-fm(mX-fY)-f(mX-fY) = mX-fmY-fmX-fmY-fmX-fY. The defaults for the explicitly written chaining operators can be overridden by explicitly writing modifiers with their operands. It would be nice if there also was a way to override the defaults of the chaining operators 'spread around' by the exponentiation. Note that you cannot do that by writing them in the base unit, as they then would also apply to first and last factor in the chain. We therefore allow notations like Arc03, to mean cA-rcA-rA. I.e. the modifiers on the exponent redefine the defaults for the chaining operators implied by the exponent. So by default A3 means Afm3.

This allows convenient notations for crooked and circular riders: Nfr8 would be upto 8 repeated Knight jumps, each next one aiming 45 degrees right of the previous one, rather than continuing straight on as a limited-range Nightrider. This is an alternative notation for qN, the Rose. And (F-lF)r0 expands to (F-lF)-r(F-lf)-r(F-lf)-... = F-lF-rF-lF-rF-lF-..., which is the Crooked Bishop, with a highly accurately defined amount of crookedness.

A few more issues that I haven't thought through very well yet:

Royalty - Bex proposed a modifier to indicate royalty, but I wonder how useful that is. Betza notation is about indicating moves, and the concept of royalty doesn't only affect the royal piece, but the moves of every piece. (You cannot move pinned pieces, and when in check you cannot move most pieces.)

Nevertheless I see some use for a modifier that indicates you cannot make the move (or leg of a multi-leg move) when the square you are going to is under enemy attack. This can be useful for the 'pas through check' issue on castling moves. It can also be useful to encode the Chu Shogi restrictions on Lion trading, where you cannot capture a protected Lion from a distance with another Lion.

Flags - For encoding of e.p. captures it would be nice to have some support for e.p. rights. Such rights are just as much apart of the game states as the occupancy of board squares, so it would be logical to have moves that affect them express this explicitly, just as they explicitly specify they will clear out a specific square they jump over.

One way to do this would be by introducing pseudo-atoms S (set) and T (test). S would remember the current square, T would compare the current square with the remembered square of the previous ply, and fail (= block the move) if they are not equal. This would allow encoding for the FIDE Pawn as

The last three moves (in parentheses, for clarity only) would describe the double push (initial only, and at the end remembering the location of the pushed Pawn), and the rightward and leftward e.p. capture, respectively. The latter capture a sideway adjacent Pawn via a W step, but then test with T if this Pawn was just double-pushed. If not, the move is blocked, but if it is, it steps forward to its destination. (Clever use of the chirality rules would allow merging of both e.p. moves to a single chain, starting with fscW, but I did not want to cloud the discussion here with that.) Seems straightforward enough to be worthwile...

Berolina e.p. is more tricky, because neither the skipped square nor the location of the e.p.-capturable Pawn provide enough information to unmbiguously specify the allowed capture. So you need to remember both, which requires a further specification of S and T. This could be written as S1, S2, ... (a bit ugly, because the literal interpretation of this would be repetition of the S or T atom, which is not what we mean, and would be pointless). So Berolina Pawns would become

S2 remebers the Pawn position, and the first sideway W capture checks if it removed that Pawn. Then it doubles back to the square originally in front of the capturing Pawn, and test there with T2 if it is now on the square skipped b that Pawn. (Note there is no need to specify this should be empty: the double-push already verified that.)

Limiters - Modality modifiers restrict what an atom can do, e.g. c for capture only. They might not always restrict it enough, however. Suppose we are playing with an 'iron' piece that cannot be captured. Or perhaps 'relatively iron', so that it is only immune to capture by a certain piece, or even by a certain move of a certain piece... The Ultima Chamelion suggests itself: it can capture pieces only in the way pieces capture it. And the way we implement the explosions of Atomic Chess, by having 'ejected fragments' capture the surrounding pieces, needs to exempt Pawns. It would be nice if we could detail the c modifier to more precisely specify what exactly we are allowed to capture. (Where the default of course is 'all opponent pieces'.) Like c{L,+Ky} for "can only capture Lion or promoted Kylin", or c{!P} for "cannot capture Pawn". A 'reciprocal capturer' in a FIDE context would be

Knight-relay Chess could also use a limiter on the t modality that hops over own pieces only: every piece would have the move t{N}N-bN-aN, which tests if there is a friendly Knight to hop over at a Knight-jump's distance, and when successful doubles back to the square of origin, and from there moves like a Knight in all directions. It had to make the small detour to pick up the Knight move!

Absolute location - Characteristic for Chess is that moves of pieces are defined relative to the square they are on. There are a few exceptions, however. In Chess960 a King always ends up on g1 after O-O, no matter where it started. It would be nice to have a way to describe "move to g1". This could be done in a general way by allowing a pseudo-atom to test if you now are on g1. This makes it easier to put restrictions on how you could move to g1, which, after all, might not b possible from anywhere, or always. (E.g. with Chess960 castling it would not be possible if the squares between your King's current location and g1 are occupied.) So you can use the full power of Betza notation to specify any method of locomotion, and then chain the pseudo-atom that tests if you are on g1 behind it.

In fact this looks very much like what the T pseudo-atom did. That one tested for being on a square that was remembered from a previous move, what we want now is doing the same for a constant, absolutely given square. Like T#g1. At some point in the description of the castling you could then have R-T#g1, meaning "slide like a Rook to g1", which would fail if a Rook could not get there. Looks a bit ugly, though. (But then again, Chess960 is an ugly variant. ;-) )

Suicide - Perhaps I was a bit rash in proposing xx as a special notation for a self-destructive eruption (= explosion). There already existed a way to encode this without this special rule. Pieces cannot destroy themselves, as you pick them up first (or the O atom would always be blocked), so dO does not work for suicide. But fragments from an eruption can kill you, if you are not careful to disperse them. A -xadK suffix on a move would expose all your friendly neighbors to lethal fragments, but -xdO would only expose yourself (just as lethally). For pure Kamikaze moves this does not seem inferior to the -xxO suffix that the extra rule had in mind. And for Atomic captures you would simply write -xdO-acdK suffixes on capture moves, specifying the fragments first destroy yourself, and then move on in all directions for a K step that captures and destroys.

User-defined shortcuts - This perhaps is a bit beyond the scope of Betza notation per se, but in definition of an entire game it might be convenient to be able to define your own atoms. Any Betza notation between parentheses behaves like it is an atom, syntactically, after all. To define Atomic Chess, it becomes a bit tedious to suffix every capture move with -xdO-ac{!P}d{!P}K. This whole combination could be written as -X, after the user defined what X means.

Creating objects - In a game like Amazons, a move consists of moving a Queen, and then having it throw an arrow to an empty square. So the move creates something that was not there before, rather than just moving or capturing pieces. Seirawan gating also does that. Perhaps this could be handled by creative use of the u modality modifier. This now is defined to 'unload' what you picked up in a previous leg by capture. Its use could be allowed even before you captured something, unloading something any piece 'carries' by default. This would solve the Amazons problem, where both sides throw the same dead objects, and mQ-auQ-ebQ would do it. Another interpretation of an 'unprimed' unload could be that you unload something from your holdings by default (where in Amazons your holdings are stuffed with Arrows, which have no moves). This would solve Seirawan, where every piece could get an extra version of its normal move prefixed with iuO- to unload a held E or H on the starting square of a virgin move. An alternative is to slam a limiter on the unload modality, u{L} to detail what you can unload.

Some more directional nitpicking

The default continuation in the 'forward' direction when chaining steps is often ambiguous. E.g. if F or N follow W, or W or N follow F. So without use of explicit directional modifiers, such chains would fork. First I thought this was a very powerful feature, being able to express a lot of moves at once.

Now I came to realize, however, that it is in fact a very undesirable feature. W-F-W would fork both at the F and final W, and (when starting forward from e4) could move e4-e5-f6-f7, e4-e5-d6-d7, e4-e5-f6-g6 and e4-e5-d6-c6. But the latter two are a sort of lame multi-path detour Alfils, while the first two are a specific form of lame Camels. Having the same notation specify both these quite different moves is only annoying, unless they would usually occur together on the same piece. (While it is in fact very unlikely they ever would.) Because then you would have to start fiddling with directional modifiers to indicate which of the two you meant. It is like doing away with the F and W atoms, and forcing the user to use flfrblbrK when he means F, and vsK when he means W.

So I wanted to put the additional requirement that chains can never fork, except when the steps can go in completely independent directions, specified by 'a'. (This is actually pretty common.) In particular, this means that the default interpretation, in absence of explicitly written directional modifiers, must always single out a unique direction as the 'most-forward', even when strictly speaking there are two completely equivalent ('degenerate') moves.

The rule I want to adopt for this is that when the previous step does not uniquely define what 'forward' is, as in W after F, you would look at the step before it to decide which of the two you should take. (And so on, until you reach a decision.) So in the W-F-W example, at the second W after e4-e5-f6 the choice is between f7 and g6. But compared to e4-e5 f6-f7 is forward, and f6-g6 is right. So f7 wins, and the chain W-F-W specifies a Camel move by default. Should you want to indicate the other one, you would have to write explicit directional modifiers. Once it is established what 'f' means, the other directions can be indicated in the non-degenerate 4-fold or 8-fold (W and K) systems. It would be illegal to use non-unique directional specification (other than 'a'), like s, v, fh in continuation steps.

This leaves the problem when all previous steps are in the same direction, which will certainly be the case if there is only one. But then the two possibilities are indeed mirror images belonging to the same atom. So it is not very objectionable to have both; the worst it could mean is that the chain now specifies 8 symmetry-equivalent paths, rather than 4. Which, for an oblique path, is in general what we want anyway. so W-F to specify the 8 moves if the Xiangqi Horse is fine.

But the two paths will have different chirality, being mirror images, so that l and r would have reverse meanings further down the chain, which would cause a problem in case we want to use explicit directional specs. So we adopt the convention that we use l and r always as if the first breaking of 4-fold symmetry in the path goes to the right. This breaking can be the first bend in the trajectory, or the first move when it is oblique. In the latter case, moves like e4-f6, e4-c5, e4-d2 and e4-g3 (right of the closest orthogonal axis) are considered to go right, the other four Knight moves are considered to 'go left'.

To avoid mix-ups with l and r, we adopt the convention that chains must always bent to the right first, but that when we write them, we mean both the written one and its mirror image. Thus W-flF would not be a valid specification of a 'Chiral Horse'. So what if we want to specify a piece that moves like that? Well, W-F defaults under the new rules to W-frF, and specifies 8 different (overall N) moves: 4 because of the leading W, and then two mirror images each because the trajectory bents. The directional specs for the degenerate 8-fold case (Knight moves) can thus be used to select directions from this. f(W-frW) would still specify two moves which are mirror images of each other (as fN specifies two such moves), and lf(W-frW) would then specify only the left-handed one of those (like lfN would).

To make the parentheses superfluous, we can adopt the convention that the first member of a chain can never have a directional modifier, and that directional modifiers written there always apply to orient the chain as a whole (but by specifying the starting direction, not the overall direction). This seems fitting: it makes chains just like atoms, who also always specify all symmetry-equivalent moves.

Example - We can write e.p. capture,which involves two chiral mirror-image trajectories to trample its victim and then move to its destination, as fscW-rmW. The cW-rmW would specify a move like one orthogoal step forward, then one orthogonal step right, and satisfies the chirality rule of bending to the right. But it represent all 4 moves that are rotated versions of it, as well as their 4 mirror images. The e.p. capture only uses two of these, that start to the left or right, and then curve 'up' (which is left for one, right for the other). The corresponding Knight moves that do this would be fs, hence this is what has to be written in front of it.

The formal grammar of this extended Betza notation would become:

SPEC := DIRECTED_PATH | DIRECTED_PATH SPEC
DIRECTED_PATH := DIRECTOR PATH | i DIRECTOR PATH
DIRECTOR := DIRECTIONSET | DIRECTIONSET DIRECTOR
DIRECTIONSET := v | s | fh | fs | bh | bs | rh | rv | lh | lv | DIRECTION
DIRECTION := f | b | l | r | a | fl | lf | fr | rf | br | rb | bl | lb | EMPTY
PATH := QUALIFIED_SLIDE | QUALIFIED_SLIDE - DIRECTION PATH
QUALIFIED_SLIDE := SPECIALS MODALITY SLIDE | SIGNAL
SPECIALS := SPECIAL | SPECIAL SPECIALS
SPECIAL := e | x | xx | EMPTY
MODALITY := ACTION | ACTION MODALITY
ACTION := m | c | d | p | t | u | o | i | EMPTY
SLIDE := STEP DRESSED_EXPONENT | STEP
DRESSED_EXPONENT := DIRECTION MODALITY NUMBER
STEP := ATOM | ( PATH )
ATOM := O | W | F | D | N | A | H | L | J | G | COORDS
COORDS := ( NUMBER , NUMBER )
NUMBER := DIGIT | DIGIT NUMBER
DIGIT := 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
SIGNAL := PSEUDO_ATOM | PEUDO_ATOM NUMBER
PSEUDO_ATOM := T | S 
EMPTY :=

Besides entertainment in 150 invented CVs, Betza's two main goals are attested to in comment of this very same 10-year-old article: http://www.chessvariants.org/index/displaycomment.php?commentid=2466.  One, Chess Different Armies eventually overtaking standard f.i.d.e. Mad Queen 64 squares.  Two, his Notation catching on and being extended.  Joe Joyce did more than anyone else towards that, until now that in just a week H.G. Muller has written more than Ralph himself ever did on the system. 

Yet with no article by Muller, doesn't 'Man & Beast 01 to 21' by Charles Gilman already cover much of the same ground being extended in Betzan, 'Man & Beasts' doing so other than notationally? For example, Betza/Muller 'm' to indicate move and capture divergence corresponds to 'Man & Beasts 02: Shield Bearers', which English-names up to 100 divergent piece-types.
Betza develops mathematical system of piece-types to be extendable, and Muller then creates modifications having programmer-conscious disambiguation. [Notation may as well represent 
entire CVs too not pieces alone with no need of ordinary wording for part or for whole.]

'Man & Beasts' anoint plain English names systematically on logical pieces up to about 32x32 square. Not only that, there are other geometries in 'Man & Beasts': hexagonal, tetrahedral, and the several three-dimensional ones. So far Betza/Muller Notation does not extend to other than square-based movement and rules and has a ways to broaden and catch up.  Since there is much coverage overlap, maybe already Betza-suggested standards committee could come into play. 

Or alternately it could be said the Betza/Muller notational approach should merge with the Gilman nomenclative approach for better unified system.

Yes, George has seen it right. I do want programmer accuracy, for exactly the purpose he describes: allowing defenition of complete Chess variants. I imagine multi-variant engines such as Fairy-Max, Nebiyu and Sjaak to allow the use of Betza notation in their configuration files for defining the variants they play (where now they use (often very cumbersome) custom notations). And in any case I would want those engines to send the description of the variant to the GUI, so that the latter becomes fully rule-aware, and can do tasks like legality checking, highlighting possible move targets of a picked-up piece, indicating victims of a capture you hover over, convert moves to and from Standard Algebraic Notation, detect check and checkmate, etc. So that all that people would need to do is add the Betza-style definition of the variant plus the initial setup in a configuration file to have a full-fledged program to play it.

Resurrection

The 'limiters' I introduced on actions like capture or hop did allow general probing for an activator in the environment, such as needed in Knight-relay Chess: just start in any direction to see if you find a friendly Knight to hop over with a 'bouncing hop' (dismounting it on the same side as you mounted it, t{N}N-bN, and then continue with a Knight move. This is something like a programmer's OR operation: the piece can do the final Knight move if in any one of the eight directions it probes for a Knight it finds one. It is in fact a multi-path move: you have to find your way over a Knight first before you can do anything, and all possible paths along which you are allowed to do that eventually merge to end on the same square.

The opposite of an activator is an inhibitor, like the Ultima Immobilizer. It would be nice if the notation could also handle such kind of pieces. But the logic is opposite: all squares in a certain neighborhood should be free of Immobilizers, not just one. For an inhibitor that would only prevent its neighbors from moving radially away from it, it would be easy. You would just write a prefix mtop{!I}K-bK- in front of the moves of pieces that could be affected by it. This would force the move to begin with a K step (in the opposite direction of where you would eventually end up) and then back (-bK), which would succeed if you (1) found an empty square there (m) (2) found a friendly piece and hopped over it (t) (3) brought you off-board to quickly retract the step (o) (4) found a piece to hop over that is not the feared immobilizer (p{!I}). But making the same probe in all directions to handle an omni-directional inhibitor, by decoupling it from the direction of the eventual move by prefixing the latter with an a does not work: It would allow the move if there is any path that avoids the immobilizer, immobilizing only pieces that would be completely surrounded by immobilizers...

It turns out that the notation as proposed can already handle this, provided we adopt a new convention. This convention is that the fragments ejected by an eruption specified by the x modifier are allowed to come together again, to resurrect the exploded piece. This resurrection would only succeed if all the fragments would coalesce. If only a single one would be missing, the resurrection fails, and the move is aborted.

This convention allows us to test for an adjacent immobilizer by a prefix xmtop{!I}K-bK-a. The logic for each individual fragment is the same as before: it can return to the initial square (where the explosion took place) in all cases except when it would have stumbled on an Immobilizer. But if one of the fragments does, because you were indeed sitting next to an Immobilizer, its path is blocked, so that it will not return to the explosion square, and resurrection there will fail. Without adjacent Immobilizer resurrection succeeds, the fragments become the real piece again, and continue the rest of the path as real move. (The a direction al modifier specifying that the move can go in any direction. Perhaps this should be implied after resurrection, as the previous step has no unique direction, fragments coming in from all directions, and is basically a null move. So what is 'forward' after this can only be defined in relation to the step before the explosion. And as the explosion was the first step here, this would mean the initial directional spec for the entire path, which by default is a.) If resurrection fails, because one of them did not make it back, the fragments evaporate as usual. They are 'rounded down' towards zero, as it were.

Excellent work on all of this.  At first I was skeptical you would be able to encode this much information in a Betza-like string, but after reading this (and your plans for algorithmic interpretation on TalkChess) I'm becoming a believer.

The only change that would make me happy would be to change the standard atoms for camel and zebra to 'C' and 'Z' (a transition that I think most everyone has made anyway.)  L and J can be synonyms, but as long as an updated standard is being published anyway ...

Although the proposed Betza 2.0 notation allows one to describe almost any complex move, even castlings or catapult pieces, the descripton easily gets very long and cumbersome. And the power of Betza notation is its compactness, which is achieved by choosing good defaults, coinciding with the needs of the common case. The vast majority of pieces in Chess variants is totally symmetric, so that an atom by default means 'all symmetry-equivalent moves with this stride' makes that you almost never have to go into the complexity of writing directional modifiers, and the rarity of divergent pieces means you almost never have to write explicit modalities m or c, as mc is taken as default.

So it would be nice to have some 'convenience notation' for very common cases that in the formal system would need a complex expression. Just like Q is a convenient shortcut for W7F7 (or WWFF). And the most common cases are of course castling and e.p. capture; most variants have those.

Now that I am actually implementing a method for engines to inform the WinBoard GUI on how the pieces occurring in a variant move (so that the GUI can do legality testing, highlight target squares of a picked up piece and make sensible move notation), by sending the moves in Betza notation, I noticed how important that is. As with everything, you have to start simple, but in original Betza notation there were no provisions for e.p. and castling. So I want to propose the following shorthands that don't need the complexity of chaining that is the heart of Betza 2.0:

(1) 'e' is an new modality modifier next to 'm' and 'c', meaning e.p. capture. The latter is defined as capture of the piece the opponent just moved with an initial move (which was prefixed with 'i' modifier), by moving to the square that it just skipped. E.g. FIDE Pawns would have an ifmnD (=initial forward non-jumping Dabbaba non-capture move), and the combination i&n here triggers the creation of an e.p. square (namely the square where the move could have been blocked). A move feF on the Pawn would allow it to move to that e.p. square, removing the previously moved piece from the board. This would make: FIDE Pawn: fmWfceFifmnD Berolina Pawn: fmFfceWifmnA

(2) 'O' is not an original Betza atom, but many extensions use it as null-move. As such, any repetition of it, like O2, would be pointless, as would be any modifier prefixes. I therefore propose to use O + number as a shorthand for (conventional) castling. (After all, castling in PGN is denoted as O-O or O-O-O.) The number would indicate how many steps the King moves. The move of the Rook (or in general, the corner piece) is implied: it ends up next to the King on its other side. Also implied is that you cannot move through or out of check, and that all squares between King and corner have to be empty. So the full description of a King would be FIDE: WFisO2 Capablanca: WFisO3 (The rule that all squares between King and corner should be empty implies a non-capture. I guess the 's' could be implied too by making it default; 'l' or 'r' explicit modifiers would make sense, however, for asymmetric castlings like in Janus Chess.)

Multi-leg moves in simple Betza notation

Again I had an idea for an ad-hoc extension to Betza notation, which would be totally redundant in the much more general (and complex) Betza 2.0 proposal. The latter distinguishes itself by allowing chaining of different atoms into multi-leg moves, which is very flexible, but rarely needed. In original Betza a move always only involves a single atom, and lots of modifiers on it. This is often good enough. Many pieces can make multiple steps, but then they almost always repeat the same step, and original Betza notation provides for this with numeric suffixes like W3.

I consider it useful to see how far one can stretch this single-atom paradigm. It will never be able to do as much as Betza 2.0, but it has the virtue of great simplicity. And simplicity is IMO the key to success. So there definitely is room for a Betza '1.5', as it were.

So I wanted to add a modifier 'a' (still one of the few unused lower-case letters!), standing for 'Again', allowing a repeat of the atom to which it applies with an Arbitrary direction change. So aK is a bit like K02: exactly two King steps, but unlike K02 the second step does not have to go into the exact same direction as the first, but can go in Any direction. Like in K02 the intermediate square must be unoccupied for the move to be possible. In Tenjiku Shogi this would be called an 'Area move'. You see, lots of reasons to use 'a' for this! :-)

Now a unique thing about 'a' is that it is an ordering modifier. Normally Betza modifiers can be arbitrarily permuted, but w.r.t. 'a' it really makes a difference whether they are appearing left or right of it. Because what appears left of it pertains to the first step, and what appears right to the second. Using this convention to write the default move modality, aK = mamcK: the first step cannot capture, the second can move and capture. (Having plain 'm' as default modality for non-final legs might not be optimal, though; See below!)

Multiple repeats can be indicated by simply repeating the 'a' prefix: aaK = mamamcK would be a range-3 area move, as the Tenjiku-Shogi Vice General and Fire Demon have. Now if we want to describe the Chu Shogi Lion, the usual way is to say KNAD+something, where the 'something' must account for the two-leg moves that affect the intermediate square. (Without affecting that square, they would be equivalent to the direct jumps already given by KNAD.) Using the 'a' modifier this could be written as caK, a 2-step area move where the first step must capture, and the second step can move or capture. In fact, we could add the good old hopper prefix 'p' here, to indicate that the move could also hop over occupied squares: pmcaK. This would make the KNAD completely redundant! Note that it is most useful to interpret the 'p' as applied only to the following 'a', rather than to the move as a whole. This would allow you more precise specification of where the hop can be taken when there are more than 2 steps. I.e. paaK would be different from apaK, as the first must traverse occupied-empty-empty/foe, while the latter needs empty-occupied-empty/foe. (Note that aapK makes as much sense as pK: none.)

Now we did not account for the Lion's null move, when it uses the second step to retract the first. The consensus is that a Lion can only do that if there is a neighboring empty square. (Which is a bit illogical: if it can make a D move when completely surrounded by pieces on all K squares, why would it not be able to hop back and forth over them?) So the O atom that is sometimes proposed for a null-step cannot be used for it, as it would convey an unconditional null move. Unfortunately the pmcaK notation also includes an unconditional null move, as the direction arbitrariness implied by the 'a' operator does not exclude moving exactly back. And we would not want to exclude that, as caK should include the 'rifle capture' (called 'igui' in Shogi), and maK the null move. The problem is in the paK. An ad-hoc solution to that would be to make use of that other hopping modifier, 'g', to indicate the difference. This modifier specifies you should land immediately behind the obstacle. We could make a liberal interpretation of 'behind' in the context of bent trajectories, arguing that exactly retracing your step is in fact stopping in front of it, rather than behind. So 'pa' would be a hop that could change direction truly arbitrarily, while 'ga' would exclude a 180-degree reversal of the path. With this convention, the Chu Shogi Lion would be completely described by gmcaK. (Note that the single K steps can always be made through a detour, as gmc effectively allows you to ignore the square altogether.)

Now Chu Shogi also has pieces (Eagle and Falcon) which can do a linear two-leg move, more general than W02 or F02 because it is allowed to reverse direction: out-out or out-in. Like with the Lion's two-leg move, they don't have to stop when the first leg is a capture. The linearity restiction can be indicated by putting directional modifiers on the second step, i.e. behind the 'a', with the interpretation that 'f' means outward (i.e. relative to the previous step, like in Betza 2.0 continuation steps). A Checker's capture would be fcafmF this way: fcF for the first leg that must capture forward, followed by an F step in the same direction to an empty square. The Eagle could also reverse direction, and would thus have fcavF (as v = fb = out or in, and there is no restriction in this case that it ends on a formerly empty square). Incorporating also the fA leaps and the conditional null move would make it fgmcavF. (Where the 'g' modality would suppress the 'b' component of the next leg's 'v', reducing to an over-all jA, but the 'mc' modalities would both allow it, for null move and igui, respectively.)

The large Shogi variants (Dai Dai and up) have 'hook movers': Rooks or Bishops that can turn one corner. This can be written as asR or asB, the second leg being sideway (i.e. at 90 degrees). Turning a corner happens to be optional, so the full description has to be RasR or BasB. (Unfortunately the simpler aR does not do, as the afR that includes does miss the W steps. WaR would do it, though!)

Another complex piece there is the Lion Dog: three in/out steps along the same ray, which could capture or jump on the way. The (exactly) 3-step component of that would be pmcafpmcavK: the first two steps would go outward over empty or occupied squares, optionally cleaning them out if they contained a foe. Then you would either step back to the first or go on to the third square, with full move/capture permission. This includes the one-step moves, by taking the second step as 'pm' and the third as 'b'. So it has to be supplemented only by the Eagle-like two-leg moves gmcavK.

As a final application there is the Free Eagle of Tenjiku Shogi, which moves as Queen, or can make a two-leg Ferz area move with 'Lion powers' (i.e. continue after capture). This would be QgmcaF.

Hmm, after having written all this, I cannot help noticing that this combination gmc/pmc occurs very frequently. That starts me wondering if it would not be a more-convenient default for the non-final legs than a plain m. With gmc as default modality we would have:

Lion:       (aK)
Checker:    fmF(fcafmF)
Falcon:     BbsR(favW)
Eagle:      RbB(favF)
Lion Dog:   K(avKafavK)
Hook Mover: (WmaR)
Capricorn:  (FmaB)
Vice Gen.:  BcppB(mamaK)
Free Eagle: Q(aF)

where I wrote the parentheses only to highlight the multi-leg moves we discussed. That looks really compact! Despite the need for an extra plain K on the Lion dog, as the g/p convention would forbid the realization out-outhop-in of the afavK move to mimic the one-step move, and it would take more writing to overrule the default gmc to pmc than just writing the one-step moves separately. (Which is less contrived anyway.) The extra 'm' needed on the hook movers and Vice General is just a very small price to pay.

So let's give 'a' moves Lion power (gmca) by default!

Some more ideas to get more mileage out of the single-atom system. Please tell me whether this is getting too weird or far-fetched!

The original g ('Grasshopper') modifier is a restriction of the p ('Pao') modifier, where the platform must be adjacent to the destination square. One can also imagine a piece that is the 'time-reversed Grasshopper', where the platform needs to be adjacent to the square of origin. Another way of viewing the Grasshopper is like a Cannon where the slider move downgrades to the corresponding leaper move at the platform. The time-reversed Grasshopper would upgrade the leaper move that managed to reach the platform to the corresponding slider. So if we assign the g modifier this general two-way slider<->leaper conversion property, it would be natural to write the time-reversed Grasshopper as gK (which originally made no sense).

Unfortunately this is not yet enough to describe 'skip-sliders', which skip the adjacent square before starting to slide. Tenjiku Shogi has such a piece, the Heavenly Tetrarchs. Apart from the time-reversed Grasshopper, it would also require a hop-less version of the move, when the adjacent square is empty. So spontaneous upgrading from leaper to slider. Now it is a co-incidence that the letters d and u are both still available! So we could use the 'again' operator to specify a two-leg mode, and explicitly write a u or d on the later leg to specify it uses an upgraded or downgraded version of the atom that was written. This is a kludge to use the same atom as both a slider and leaper move: we can write uW to mean R in any context (like WW, W7 or W0 wasn't already enough...).

So we could write mpafuW to describe the Skip-Rook: make a Wazir step to an empty or occupied square without touching it, and then make again a Wazir step, an unlimited number of times. Of course the original Betza 'then' notation could also do this, as t[D,R], glueing a Rook move to the D leap that skipped the square. I never liked that notation much, however; it seems quite out of line with the normal Betza syntax.

Now the 'then' notation was originally developed for describing bent riders. The 'a' notation also allowed bent trajectories, as in the example of hook movers, by putting a directional modifier on the second leg. And the choice is especially large on the pseudo-atom K.

Now originally it made little sense to have directional selection from an 'atom' that in itself already joined different directions. It would almost always be much simpler to just put them on the W or F components. But in a continuation leg it is very useful to put f or v on them, to enforce a linear path without having to write the orthogonal and diagonal paths separately. So we already have crossed that bridge. Now the K has non-degenerate 8-fold symmetry, non-degenerate because, unlike oblique true atoms there is a unique forward move, in stead of a pair. So we need a different system of direction specification.

Some analysis shows we could require here that the sideway direction always precedes the vertical direction, as there are only 4 directions that have components along both dimensions. The other 4 can be written by single direction specifiers. With this convention, rf would mean the single rightt-forward direction, while fr would be non-combinable, and describe a pair of directions, pure forward or pure right. This way it becomes possible to write svK = (l+r)(f+b)K = (lf+rf+lb+rb)K, all combinable and thus indicating diagonal directions. I.e. svK = F. OTOH, vsK would have a non-combinable v+s, meaning joining their direction sets, so f+b+r+l, all indicating orthogonal direction. Thus vsK = W!

Now we could write vsmasfK. In the K directional system sf is combinable, (l+r)f = lf + rf, i.e. continuation with 45-degree deflection, while the direction specification vs for the first leg was the Ferz. In other words, we have described the Mao as a two-leg King move without hopping ability. The Moa would similarly be svmasfK, and the Moo masfK. The latter was the fully 8-fold pseudo-symmetric bent-lame-leaper move, and the vs or sv prefixes were just needed to pick the W and F starters from it.

Now combining this with the 'upgrade' modifier, we get vsmasfuK for the Gryphon, which is essentially a Mao with an elongated second leg. Similarly the Ancaa is svmasfuK. (Good thing they were not capture-only... ;-) ) The F or W moves will have to put on them separately (if we want them to have those).

We can do bifurcators too, as these are similar to bent riders, except that they don't bend spontanously, but at the platform. So the ultimate bifurcator is gasfQ: move as Q to the nearest occupied square, and then again as Q, but in the relative sideway-forward direction (i.e. at 45 degrees). With the vs or sv prefix you could select the parts of this that start in the Rook or Bishop direction. Of course by giving different directional specs behind the 'a' you could also turn 135-degree angles. For 90-degree angles it would of course be more clear to simply write gmasR or gmasB, as there the trajectories are orthogonal or diagonal all the way, and R reads a lot clearer than vsQ! Of course the compound of these is gmasQ.

So with the u modifier, and abusing the pseudo-atom K, we can actually achieve a lot of quite useful stuff within the framework of the single-atom + modifiers system!

Simple Betza notation for Multi-leg moves

The modifier 'a' ('again') describes that the piece can do an extra move after the first move (described by the modifiers left of the 'a') has been completed. This continuation is then described by the modifiers right of the 'a', with the understanding that directions there are relative to the immediately preceding step, 'f' specifying continuation in the same direction. E.g. fcafmF is the Checker capture, first leg fcF, followed by an obligatory fmF, i.e. in the same direction. Default modality on a non-final leg is 'm', rather than 'mc' on final legs.

Continuation direction - Continuation legs always use the 8-fold K/Q system for specifying directions. We adopt the convention that specifying an intermediate continuation direction (like fr) converts orthogonal to diagonal atoms, and vice versa: F interconverts with W, D with A, G with H. This allows description of paths that bend 45 degree or 135 degree. E.g. afsW is a Mao, afsF a Moa and afsK the (multi-path) Moo. Oblique atoms or K already have these directions by themselves, and require no identity change. (But in the case of K still involves interconversion between its W and F constituents).

Awkward detail: to prevent that afrN means something different on the rfN move than on the lfN move (a (3,3) move vs. a (0,4) move), the 'l' and 'r' must also be interpreted relative to the first 'sideway choice', 'r' meaning the same direction as that choice. Perhaps a better alternative is to have shorthand notations for direction sets that include only the right-handed four or lefthanded four moves of an oblique leaper, ('hr' and 'hl'?), so that it becomes bearable to specify them separately, using 'r' and 'l' in their ordinary meaning as they are needed (e.g. hrarfNhlalfN). For now we declare the result of explicit use of 'l' and 'r' in continuations of an oblique atom simply undefined.

The default direction set for continuation legs is all directions except exactly backwards, where 'all' is the 4 principal directions for 4-way atoms, and 8 directions otherwise.

Modality -The 'p' and 'g' modifiers in a non-final 'leg' indicate that leg should end on the first occupied square it encounters. and the following leg will then move away from there without affecting the occupant ('hop'). 'g' has the additional property that it modifies the range from slider to leaper, or vice versa, compared to the previous step. Thus pafR is a more elaborate way of writing pR, while gafQ is equivalent to gQ, the conversion to leaper forcing the move to end immediately behind the platform. The new notation can also describe pieces that change direction at the platform, e.g. pasR for a hopper that continues in a perpendicular direction there. masR = asR is a Hook Mover that can make such a turn at any empty square, and modalities can be combined as usual; mcasR can turn a corner at an empty square, or after capturing. The combined modality 'mp' on non-final legs effectively ignores the intermediate square, and can be used to 'glue' leaper moves into longer strides, e.g. mpafN for a (2,4) leaper. To make it a lame leaper, blockable at the N square, we would drop the 'p', and write mafN = afN.

New modalities - On non-final legs the modality 'y' indicates slider - leaper interconversion similar to 'g', but on an empty square rather than a hop. The exact way this is done (for both y and g) is swapping BRQ for FWK and dropping an existing range specification, or, for other atoms, changing an explicit or implied range from 1 to infinite or from not-1 to 1. This allows description of pieces that change direction (or fork) after a fixed number of steps, e.g. yafsF is a Gryphon (starts as F, 'y' changes it into slider, and 'fs' turns it orthogonal for the second leg). A new modifier 't' can be used in combination with 'p' or 'g' on non-final legs to indicate hopping is only allowed over a friendly piece.

e.p. capture or range- 'e' on a continuation leg restricts the range of that leg to be exactly the same as that of the previous slider leg. This can be used to describe rifle capture: mRcabeR is a rifle Rook. Otherwise it indicates the move can capture en-passant, i.e. moving to an empty square where an enemy lame leaper that was just moved could have been blocked, capturing the latter.

Summary

The 'again' modifier (supported by the new modifiers 'y' and 'e') can be used for: expressing longer leaper moves, laying out the exact path of lame leapers, describing general bent hoppers or sliders, describe several types of bifurcators, and describe locust or rifle captures.

Would you help me? I'm writing an interactive diagram for beastmaster chess, and don't know how to express the (1,4) and (1,5) leaps of the Pegasus and Wyvern. Could I use the bracket notation of [WL] and [DL], or would that crash it?

Unfortunately the Interactive Diagram (or WinBoard) does not understand the (,) or [] notations. The 'a' modifier allows you to glue steps together, by using 'mp' for the mode of the preceding leg, which then would allow it both to move and to hop, so that it becomes completely insensitive to the occupation of the intermediate square. The 'a' system for multi-leg moves has the limitation that all steps have to belong to the same Betza atom, however. All leaps can be written as a sequence of King steps, but for long leaps this does get a bit cumbersome. Like mpafmpafmpafsW to write (1,4) as four King steps. For (1,5) two Zebra leaps could do it, and for (1,4) three Knight moves, but it is questionable whether this would give something that is easier to understand.

I am aware this is rather cumbersome, but I don't like the other two solutions much better. The [] notation to glue moves is just as kludgy. The coordinate notation is at least general, but I don't like to reserve parentheses for this. The cleanest would be if these leaps had their own capital. But unfortunately the iconic piece for (1,4) is the Giraffe, and Betza already used a 'G', seemingly without reason, for (3,3). Of course at some point you would run out of letters anyway. Leaps longer than 3 squares are so rare that it doesn't hurt too much if they can only be indicated in a cumbersome way. Note that for lame leaps it would be necessary to specify the entire path anyway, with 'm' rather than 'mp' modality for the non-final legs.

The simplicity of Betza notation often hinges on the choice of convenient defaults (like 'all directions' in absence of directional modifiers, 'mc' in absence of modal modifiers, step/infinite range in absence of a range specifier...). Perhaps the default modality of a non-final leg should be 'mp', then the (1,4) move would simplify to afafafsW, which reads somewhat easier. The corresponding lame move would then be mafmafmafsW. But in WinBoard I defined the default modality to be 'm', under the assumption that short-range lame leapers would be more common than very-long-range leapers.

The markers for the U atom are screwed up. Typing in U gives weird grey squares with weird pictures on them.

OK, fixed. The marker images have names derived from the colors, and but at one point I had changed the orange to another shade in an attempt to make it distinguishable on a grey-scale display (as you noticed), and in this place I forgot to change it back when this turned out to be a failure. The images you saw were just the browser defaults for "missing image".

I wonder how I can make the Crooked Vao display correctly

Unfortunately crooked pieces are not yet supported, neither by XBoard nor by the Interactive Diagram. The 'z' modifier is also a bit ill defined (and likewise 'q') when applied to oblique leaps. Three different kind of crooked Nightriders would be possible. One could of course define it such that one always has to take the minimal deflection, as with 'q' for the Rose. For a crooked Nightrider this is not the most-likely choice, though.

I implemented a new enhancement of XBetza notation in XBoard, to be able to more precisely indicate generation of e.p. rights on oblique moves. 'Non-jumping' is an ill-defined concept for those; nN could be a Mao or a Moa, so with the existing convention ifmnN would not sufficiently specify what the blocking square (and thus e.p. square) is. For that a multi-leg description fully specifying the path is necessary, like mafsW for the Mao.

XBetza uses the 'e' modifier to indicate e.p. capture, as alternative to the 'm' and 'c' modality. But this only seems useful in the final leg of a muti-leg move. So I redefined the meaning of 'e' in a non-final leg to me an 'm' move that generates e.p. rights on its target square. This would make the double-push of a FIDE Pawn ifeafmW. (And its e.p. capture feF, which can combine with the normal capture to fceF.)

[Edit] On thecond thoughts I wonder if it wouldn't be better to use the 'n' modifier instead of 'e' for indicating generation of e.p. rights by a non-final leg, and reserve the latter for actual capture. When laying out a lame-leaper trajectory one will almost certainly use a stepper atom (W, F or K), and 'n' can never have its traditional non-jumping meaning there. OTOH, e.p. capture on a non-final leg is not completely out of the question: one could want to define an e.p.-capturing Checker, feafmF, where the 'e' on the non-final leg then means that leg should end on the e.p. square (by definition empty), and that the move as a whole leads to removal of the previously moved piece as a side effect. Double-push FIDE would then become ifnafmW to generate e.p. rights.

does anyone know why mFyafsmFpafscB1yafscpF also gives the rook squares as capture squares?

No, it would not. Betza atoms never describe null moves (unless one would have defined an atom especially for that), and even if the number of steps is variable, such as in B or R, it must at least make one step and cannot stay in place. The use of the 'a' modifier to define multiple legs doesn't alter that: each leg must at least take 1 step (and if it is a leaper leg, that would be the only step). All the moves you specified are bent two-leg moves, (they have 'fs' after the 'a'), and a Rook move isn't.

BTW, I would use gafscF instead of pafscB1; 'g' describes a range-toggle after hop, as in the Grasshopper (slide -> leap) or Contra-Grasshopper (leap -> slide). What you wrote should also work, but is a bit more cryptic. gafscF means an F step to the mount, followed by a Rook slide that can only capture.