## Siteswap notation

This page describes the pattern notation used by the siteswap notation component of Juggling Lab. There are two main sections:

## Description of siteswap notation

A lot of freedom exists in choosing a notation to use for juggling. In particular, there are always tradeoffs between expressiveness (how many weird patterns like Mills Mess can you uniquely describe?) and compactness. Siteswap notation is a very "compact" method, which has two major benefits: (1) it makes the notation amenable to computer analysis, and (2) it is easy for a person to look at a pattern and figure out how to do it. There is a price for this compactness, however; siteswap notation ignores all information concerning throwing and catching positions and styles, as well as any characteristics about the objects being juggled (e.g., number of spins on clubs).

When an object is thrown, the only things siteswap notation tells you are which hand to throw to, and the number of time beats until the object is thrown again. You have complete freedom in choosing how to make this happen: Make a standard throw, throw behind the back, bounce off the floor, do a helicopter spin on your head, or whatever, so long as the object ends up in the correct hand at the correct time.

Viewed in this way, siteswap notation is a very minimalist approach to juggling notation. Its ignorance of throwing styles means that tricks like the 3 ball cascade and Mills Mess get lumped together. Despite the limitations, siteswap patterns are fun to perform and can be a great starting point for adding your own creative embellishments.

#### Solo juggler with asynchronous throwing rhythm (vanilla siteswap)

The simplest case is that of a single juggler throwing alternately with both hands in a R-L-R-L kind of way (called asynchronous juggling). This is what you do in the standard cascade pattern. Each throw in our notation can then be described by a single number, namely the number of throws in the future when the object is thrown again. In a 3 ball cascade each throw is a '3', for example.

Note that the notation doesn't need to specify the destination hand, since odd numbers always go to the opposite hand, even numbers to the same hand (a result of constraining ourselves to a R-L-R-L throwing rhythm). Another way of thinking about it is this: When you do a throw 'n' (n is the throw number), throw just as you would if you were doing a cascade or fountain with n objects, at the same handspeed. A 3 is a short toss across, a 4 is higher and into the same hand, and so on.

An asynchronous siteswap is just a sequence of these numbers: The first number describes the first throw made, the second number the second throw (opposite hand as the first), and so on. At the end of the pattern you loop back to the beginning and continue.

Sample three ball tricks include (click on the patterns to see animations):

3
51
Shower (that's 5 and 1, not fifty-one)
42
Two in one hand, hold with the other (see the explanation of holds below)
441
An interesting box-like pattern
531
55500
A 3-high flash

The '0', '1', and '2' throws need some explanation. A '2' throw is thrown again two throws in the future, in other words the next throw out of the same hand. Since the hand does nothing before throwing the object again, we are free to interpret a '2' as just a hold in that hand for one count. A '1' is a fast zip across from hand to hand, as in the shower. Finally, a '0' is no throw at all; the hand is empty (the pattern 60 is three in one hand, the other hand empty).

Throws with values greater than '9' are by convention assigned the letters 'a' (10), 'b' (11), 'c' (12), and so on. In Juggling Lab these must be supplied in lower case to avoid conflicting with throw modifiers.

Are all strings of numbers jugglable patterns? No. Notice that if you average the throws in each of the above patterns you always get 3, the number of objects being juggled. This is one of the ways you can tell whether or not a string of throw numbers forms a valid pattern. '76' doesn't work, but '75' is a valid six ball pattern (commonly known as the six ball half-shower). It turns out that even this averaging criterion is not enough to determine which strings of numbers are valid juggling patterns; for a better description see the JIS siteswap help pages.

#### Multiplexing

So far in our discussion of siteswap, we have placed some serious restrictions on the pattern: There is only one juggler (solo juggling), the hands are throwing in a right-left alternating rhythm (asynchronous juggling), and only one throw is made at a time out of each hand. This simplest form of siteswap notation, sometimes called vanilla siteswap, was the first kind discovered, independently by three people in 1985: Bruce Tiemann (Caltech), Paul Klimek (Santa Cruz), and Mike Day (Cambridge, England).

What we'd like to do is expand the set of patterns we can describe, by relaxing these restrictions one by one. We start by allowing the juggler to make multiple throws out of the same hand at the same time; this is a popular juggling technique known as multiplexing.

The simplest way to notate multiplexing is to group together with brackets the throw numbers of the multiplexed throws. An example five ball multiplexed pattern is 24[54]. From the middle of a cascade, we first do a hold with our right hand, throw a shorter toss from the left hand to itself, and then simultaneously throw a 5 and 4 with the right (the hand had two balls in it, since it did the hold first). Then we can either switch back into the cascade, or repeat the trick starting with a left-handed hold -- recall that we switch hands each repetition since the pattern is of odd length. [This, by the way, is a trick that Anthony Gatto did in his act, except that he did it all while juggling over his head. He can also do 26[76] with seven balls.]

#### Solo synchronous juggler

Now we relax the restriction that the juggler throws in a right-left alternating rhythm. The simplest case is where both hands are throwing at the same time, called synchronous juggling.

Synchronous siteswap notation is very much like vanilla siteswap notation above, but with two differences: (1) we group together throws made simultaneously with parenthesis, and (2) we now need to specify a destination hand for each throw, so put an 'x' after any throw that crosses over into the other hand (a throw without the 'x' is assumed to be directed to the same hand that threw it). A '2' is still a hold, but a '2x' is similar to the '1' in the siteswap notation above: a short pass from hand to hand. A '0' is still no throw, and a '0x' is not allowed. All throw numbers must now be even.

Examples of synchronous patterns:

(4,4)
4 ball synchronous fountain
(4x,4x)
A common crossing version of the 4 ball fountain
(4x,2x)
3 ball shower with simultaneous throws
(4,2x)(2x,4)
The 3 ball "box" or "see-saw" pattern
(6,6)(6x,2x)
A 5 ball trick
(6x,6x)(2x,2x)
A 4 ball trick
(4,4)(4,0)
3 balls in 4 ball synchronous fountain (1 missing)

By convention the left slot in the parenthesis is taken to correspond to the left hand. Multiplexing can also be notated, exactly as above; for example the 4 ball pattern (4,2)(2x,[44x]) has a multiplexed '4' and '4x' thrown with the right hand.

#### More than one juggler (passing)

Imagine several people juggling, each person asynchronously, but synchronized with respect to each other (i.e., all jugglers throw with their right hands at the same time). This is the situation in 2-count 6 club passing, for example. Now our notation has to tell all people what to do, which might sound complicated but actually isn't too bad if we add a few things to what we defined above.

Divide a "throw" into several parts, the throwing instructions for each juggler. Continue to write a self-throw as a single number, exactly as we did for siteswap notation (a 2 is a hold, a 3 is a low toss to the other hand, etc.). So for example, <3|3|3|3> is a pattern that describes 4 jugglers each doing a 3-ball cascade.

What about passes? Append a 'p' to a number to represent a passed throw. To figure out which of your partner's hands to pass to, use this rule: If without the 'p' the throw would go to your left hand, throw at your partner's left, and so on. If there are more than two jugglers, put a number after the 'p' to indicate which juggler you're passing to, with the convention that the leftmost juggler in the <|> is juggler #1, the next is juggler #2, and so on. So for example, <3p|3p> and <3p2|3p1> each describes the same passing pattern, namely 6-object ultimate passing.

Some example passing patterns (note the average rule still applies):

<3p|3p><3|3>
Ordinary 2-count 6 object passing. Notice how the instructions for each person are sectioned off. Each person starts throwing with his right.
<3p|3p>
Ultimate passing, where all throws are passes.
<3|3>
Two people doing 3 ball cascades.
<4p|3><2|3p>
A left-handed double, if done once from the middle of a "cascade" (in this case <3p|3p><3|3> qualifies).
<2|3p><2p|3><[3p/2]|3p><3|3>
A multiplexed pattern, the left-handed single. Do the first hold with your right hand, since that is when your partner is doing a '3p'. The '2p' is from your left to his left, and then you resume. Note the use of '/' in the multiplexed throw, to separate the two throws '3p' and '2' (otherwise the animator would think the 2 was the target juggler for the 3p pass). This could also have been notated [3p22].
<(4x,4xp)|(4x,4xp)>
A synchronous pattern with 2 jugglers and 8 objects. Note that the 'p' comes after the 'x'. The 4xp is thrown to the other juggler's left hand, since a hypothetical 4x thrown as a self-throw from the right hand would go to the throwing juggler's left hand. Multiplexing can also be included in a synchronous pattern with multiple jugglers.
<(2p3,4x)|(2xp3,4p1)|(2xp2,4xp2)>
A synchronous pattern with 3 jugglers and 9 objects.

## Juggling Lab extensions to siteswap notation

The previous section described basic siteswap notation, which is also what is produced by the Juggling Lab siteswap generator. The animator portion of Juggling Lab also recognizes several extensions to this notation, to provide convenience and greater flexibility.

#### Conveniences: Subpattern repeats, simplified passing notation, and the * suffix

When a pattern contains a subpattern that you'd like to repeat multiple times, Juggling Lab provides a simple way to indicate this without manually repeating the subpattern. For example, let's say you want to do 10 throws of the 3-ball cascade, followed by two iterations of 531. One way to achieve this would be to use the pattern 3333333333531531.

Using the subpattern repeat notation, you can also write this as (3^10)(531^2). In all cases the result is as though the subpattern had been written out manually the specified number of times.

Another convenience is simplified passing notation, which allows you to combine together multiple beats within a single <|>. For example, 2-count passing with 6 can be shortened to <3p 3|3p 3> from the version <3p|3p><3|3> discussed above. The only restriction is that the total number of beats within a <|> must be the same for all jugglers.

A final notational convenience was introduced by Ben Beever, who noted that many popular synch patterns are symmetrical in the sense that the pattern consists of a throwing sequence which is then repeated with the roles of the hands exchanged. One example is the see-saw or box pattern (4,2x)(2x,4). The convention is to write only the first half of the pattern, and attach a "*" to indicate the hands-exchanged repeat. In this way the box pattern can be written (4,2x)*.

Juggling Lab allows you to add instructions to each siteswap throw in order to change the way the juggling looks. Each modifier is a string of upper-case letters that comes after the throw it modifies, and the main action is determined by the first letter in the string:

• B -- Bounce the throw off the floor. The format is to put as many B's as you want bounces, followed by the style of the bounce:
• L for lift bouncing
• F for force bouncing
• HL for hyperlift bouncing (for a description of hyperforce/hyperlift bouncing, see this discussion on rec.juggling)
• HF for hyperforce bouncing
For example:
• BL indicates regular lift bouncing with single bounces
• BBF indicates force bouncing with double bounces
• BBHL indicates hyperlift bouncing with double bounces
Note that a given bounce style may not always be possible if the ball is spending too much or too little time in the air. For example, it is not possible to do a double-bounce with too little time in the air. (Likewise, it is not possible to do a single-bounce hyperforce throw with too much time in the air.) In situations where the specified throw is not possible, Juggling Lab will adjust the throw/catch styles (lift vs. forced) to find something physically possible; its last resort is to decrease the number of bounces.
• F -- Force-bounce the throw off the floor, with a single bounce. (Note: this is included for compatibility reasons; use of the B modifier is preferred)
• H -- Hold an object that would ordinarily be thrown (e.g., a '4').
• T -- Throw an object that would ordinarily be held (e.g., a '2').

For example, 42T3 is the siteswap 423 where the '2' is thrown, rather than held. <(2p3,4xBL)|(2xp3,4p1BL)|(2xp2,4xp2BL)> is the three-juggler passing pattern mentioned above, only now all throws from the right hands are bounced off the floor.

#### Mixed asynch/synch notation

Juggling Lab also understands patterns in a combination of asynch and synch notations. A few examples:

41x(4x,3)
A 3-ball pattern that is pretty close to (2,4)(4x,2x) in appearance.
55556x56x1x(6x,4)(4,6x)(6x,4)(5x,7)(6x,4)
A pattern that switches between the 5-ball cascade and the synch pattern (6x,4)*. (This pattern could have been written (5^4)6x56x1x((6x,4)*^1)(6x,4)(5x,7)(6x,4) to better indicate the subpatterns involved.)

Several new things are going on here, for example odd throw values (7 and 5) in a synch pair, and throws like "1x" and "5x". These departures are required to generate the change in rhythm as we switch between asynch and synch throwing.

A few points of clarification:

• The "x" suffix is generalized here to mean "throw to the opposite hand that you would in an asynch pattern". So a "4x" is a crossing 4 as in standard synch notation, and a "1x" is a non-crossing 1 (i.e., a short hold).
• When there is a switch from a synch to an asynch section, Juggling Lab assumes that the hand to throw is the opposite of the last asynch throw made (prior to the synch section).
• Juggling Lab always assumes a single beat of no throws after each (,) synch pair. So an asynch throw after a synch throw happens two beats after the synch throw is made.
• The siteswap average rule still holds for patterns in mixed notation.

Unfortunately the appropriate transitions between asynch and synch patterns are not simple to figure out (the common method of last resort is to draw a ladder diagram on paper). Perhaps a future version of Juggling Lab will include features to aid in finding these transitions.

#### Specifying hands in asynchronous patterns

The basic passing notation assumes that when an asynchronous throwing rhythm is used, all jugglers are throwing with the same hands at the same time (as in 2-count 6 club passing). However many interesting juggling patterns break this rule, for example 2-count 7 club passing; in this case the right hand of juggler #1 throws at the same time as the left hand of juggler #2. We would like to write 2-count 7 club passing as something like <4xp|3><3|4xp>, where we identify the first juggler as starting with her right (a pass), and the second as starting with her left (a self).

Juggling Lab allows you to do this by using a hands specifier: put a L or R before any asynchronous throw to cause that throw to be made by the left or right hand, respectively. Subsequent asynch throws are made in an alternating manner from that starting point, as usual. For example:

<R|L><4xp|3><3|4xp>
The solution to the 2-count 7 club passing problem. Juggler #1 starts with the right hand, juggler #2 starts with the left.
L75
A 6-ball half shower, with the left throwing high.

A hands specifier may come at any point in the pattern; in particular there may be multiple hands specifiers, for example R3R3xL3L3x which is a pattern with an unusual RRLL throwing rhythm. If there isn't a hands specifier prior to the first asynch throw, Juggling Lab assumes the first asynch throw is made by the right hand.