We have now learnt how to represent asynchronous (vanilla and multiplex) and two-handed synchronous (including synchronous multiplex) juggling patterns in siteswap notation. A juggling performance will usually have the juggler “transitioning” between patterns. Let us explore how siteswap notation can represent transitions between different asynchronous patterns. For the sake of clarity but without any loss of generality, multiplex throws have been left out from the examples presented here. The discussion is also limited to transitions between two sequences involving the same number of objects and hands.
We will also discuss “juggling simulators”, why they can’t simulate many of the siteswap sequences we have come across during the course of this series and how to resolve this problem.
Asynchronous Transitions
Given two asynchronous siteswap sequences S1 and S2, the transition[1] between them could be the simple concatenation S1S2. For example, let us assume that S1 is the sequence “3” and S2 is the sequence “4 2 3”. Then the sequence S1S2 = “3 4 2 3” is valid as can be verified by the permutation test.
| S1 | S2 | ||
|---|---|---|---|
| 3 | 4 | 2 | 3 |
Further, we can repeat S1 and S2 any number of times. E.g., the sequence S1S1S1S2S2 = “3 3 3 4 2 3 4 2 3” is also valid.
| S1 | S1 | S1 | S2 | S2 | ||||
|---|---|---|---|---|---|---|---|---|
| 3 | 3 | 3 | 4 | 2 | 3 | 4 | 2 | 3 |
Remember that the siteswap sequence assumes that after the last throw, the pattern will loop back to the first throw. This means that not only is the transition from “3” to “4 2 3” seamless, the transition from “4 2 3” back to “3” is also seamless. In other words, S2S1 is also a valid sequence in this case.
Sometimes we may need intermediate “transition sequences” T12 and T21 to go from S1 to S2 and to return from S2 to S1 respectively. For example, consider the sequences S1 = “3” and S2 = “5 0 4”.
| S1 | S2 | |||
|---|---|---|---|---|
| Siteswap Number | 3 | 5 | 0 | 4 |
| Add | 0 | 1 | 2 | 3 |
| Result | 3+0 = 3 | 5+1 = 6 | 0+2 = 2 | 4+3 = 7 |
| Remainder of (Result/P) | 3 mod 4 = 3 | 6 mod 4 = 2 | 2 mod 4 = 2 | 7 mod 4 = 3 |
Table 1 shows the permutation test for the concatenated sequence S1S2 = “3 5 0 4” with period P = 4. We see that the Remainder Row does not contain all the numbers from 0 to P-1. Thus, it is an invalid sequence. I claim that we can use the transition sequences T12 = “5 3” to go from “3” to “5 0 4” and T21 = “1” to return from “5 0 4” to “3”. Let’s run the permutation test on the new sequence S1T12S2T21 = “3 5 3 5 0 4 1”.
| S1 | T12 | S2 | T21 | ||||
|---|---|---|---|---|---|---|---|
| Siteswap Number | 3 | 5 | 3 | 5 | 0 | 4 | 1 |
| Add | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
| Result | 3+0 = 3 | 5+1 = 6 | 3+2 = 5 | 5+3 = 8 | 0+4 = 4 | 4+5 = 9 | 1+6 = 7 |
| Remainder of (Result/P) | 3 mod 7 = 3 | 6 mod 7 = 6 | 5 mod 7 = 5 | 8 mod 7 = 1 | 4 mod 7 = 4 | 9 mod 7 = 2 | 7 mod 7 = 0 |
From Table 2, we see that the remainder row contains all the numbers from 0 to 6 exactly once, so this is a valid sequence of period P = 7. Again, we could repeat S1 or S2 any number of times as long as we retain the respective transition sequences between S1 and S2. For example, the sequence S1S1S1T12S2S2T21 is a valid sequence.
| S1 | S1 | S1 | T12 | S2 | S2 | T21 | |||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| 3 | 3 | 3 | 5 | 3 | 5 | 0 | 4 | 5 | 0 | 4 | 1 |
Interestingly, the “transition sequences” themselves, when taken in isolation, may or may not be valid siteswap sequences. If valid, they may not involve the same number of objects as the sequences they help transition between. In our example, both T12 = “5 3” and T21 = “1” are valid siteswap sequences, but are respectively for four and one objects while the transition is happening between 3-object sequences!
Just like object siteswap sequences, the hand siteswap sequence may also be transitioned. For example, consider the two-handed hand siteswap sequences H1 = “2” and H2 = “1 3”. We can use the transition sequences TH12 = “3” to transition from H1 to H2 and TH21 = “1” to transition back from H2 to H1. One can verify that H1TH12H2TH21 = “2 3 1 3 1” is indeed a valid sequence.
| H1 | TH12 | H2 | TH21 | |
|---|---|---|---|---|
| 2 | 3 | 1 | 3 | 1 |
As with object siteswap sequences, we can repeat H1 and/or H2 any number of times as long as we retain the transition sequences between them.
In the general case, both the object and hand siteswap sequences may undergo a transition at the same time. For example, the sequence of Table 3 represents an object siteswap transition between S1 = “3” and S2 = “5 0 4”, with a simultaneous hand siteswap transition between H1 = “2” and H2 = “1 3”.
| Time (in beats) | Object Siteswap | Hand Siteswap | ||
|---|---|---|---|---|
| 0 | S1 | 3 | H1 | 2 |
| 1 | S1 | 3 | H1 | 2 |
| 2 | T12 | 5 | H1 | 2 |
| 3 | 3 | TH12 | 3 | |
| 4 | S2 | 5 | H2 | 1 |
| 5 | 0 | 3 | ||
| 6 | 4 | H2 | 1 | |
| 7 | S2 | 5 | 3 | |
| 8 | 0 | H2 | 1 | |
| 9 | 4 | 3 | ||
| 10 | T21 | 1 | TH21 | 1 |
| 11 | S1 | 3 | H2 | 2 |
| 12 | S1 | 3 | H2 | 2 |
All the above transitions have been demonstrated in this video:
We had remarked in Siteswap Notation II, that the object sequence “3” with hand sequence “1 3” could be mistaken for the object sequence “5 0 4” with hand sequence “2”: both involve one hand making a crossing throw followed by a throw to itself and then the other hand follows suit. However, the difference becomes evident in the above video where the two patterns are shown side by side using the same throw rate.
Exploiting “holds”
As discussed in Siteswap Notation II, if at a beat, the object and hand siteswap numbers are the same, then this “throw” can be made as a “hold”. This has been exploited in the demonstration of the Table 3 sequence at beat #3 (both object and hand siteswap numbers are 3) and at beat #10 (both object and hand siteswap numbers are 1).
In the last demonstration in the video, the sequence “3” with hand siteswap “1 3” is juggled with “holds”. At every alternate beat, both the object and hand siteswap numbers are 3, i.e., every alternate throw (hand throwing 3 to itself) can be juggled as a hold!
Juggling simulators
Siteswap notation, with its mathematical ramifications, paved the way for creating animations of siteswap sequences using juggling simulators[2]. Let’s explore their working a little.
For asynchronous sequences, juggling simulators always assume the hand siteswap sequence “2”. So how can we simulate, for example, the sequence “3” juggled with hand siteswap “1 3”? This can be achieved by converting such sequences to synchronous sequences (which juggling simulators do comprehend) as follows:
- Treat all throws as synchronous throws.
- Assign the siteswap number 0 to the non-throwing hand.
- If the throw is “crossing” from one hand to the other, append an “x” after the corresponding siteswap number.
Let’s do this for the sequence “3” with hand siteswap “1 3”.
| Beat | Original Sequence | Synchronous Equivalent | ||||
|---|---|---|---|---|---|---|
| Siteswap Number | Throwing Hand | Crossing Throw? | Siteswap Number | |||
| Object | Hand | Object | Hand | |||
| 0 | 3 | 1 | Right | Yes | (3x 0) | (1 1) |
| 1 | 3 | 3 | Right | No | (3 0) | (1 1) |
| 2 | 3 | 1 | Left | Yes | (0 3x) | (1 1) |
| 3 | 3 | 3 | Left | No | (0 3) | (1 1) |
Why did we write this as a four beat long sequence? The synchronous notation couples information about the throwing hand with each siteswap number. A valid synchronous sequence must honour the periodicity of this coupled information. In this case, we have to go through four throws: right hand 3x, right hand 3, left hand 3x and left hand 3, before the sequence repeats. Thus, the equivalent synchronous sequence is the period P = 4 sequence “(3x 0) (3 0) (0 3x) (0 3)” or, using the shorthand notation, “(3x 0) (3 0)*”.
But juggling simulators can’t run the synchronous sequence “(3x 0) (3 0) (0 3x) (0 3)” either!
Hand speed
When the hand siteswap sequence is “2”, the fastest that the same hand needs to throw is once every two beats. Juggling simulators though operate as if the fastest the same hand can throw is once in two beats. This does make sense – there is a limit to how fast a hand can make two successive throws. The synchronous throw rate cannot be faster than this limit. The asynchronous throw rate can, however, be twice this limit as the other hand can throw between every two throws from the same hand. Simulators model this by restricting any given hand to throw only on alternate beats. Particularly, no hand can throw on successive beats. Therefore, for a simulator, the hand siteswap sequence “(1 1)” is impossible. Instead, the hand siteswap “(2 2) (0 0)” is enforced for all synchronous patterns in juggling simulators[3].
With the synchronous hand siteswap sequence being “(2 2) (0 0)”, starting at beat #0, the hand siteswap numbers at every odd-numbered beat are (0 0), i.e., no hands are available at odd beats. This will only work if all object siteswap numbers are also (0 0) at odd beats. Further, the non-zero object siteswap numbers at even beats should themselves be even numbers to ensure that the next throw of those objects gets scheduled for other even beats. The synchronous representation “(3x 0) (3 0) (0 3x) (0 3)” has neither all-zero object siteswap numbers at odd beats nor object siteswap numbers that are even. To make it consistent with the hand siteswap “(2 2) (0 0)”, we:
- Double all the object siteswap numbers.
- Insert a beat with object siteswap numbers (0 0) after every beat present in the original sequence[4].
Thus, “(3x 0) (3 0) (0 3x) (0 3)” with period P = 4 becomes “(6x 0) (0 0) (6 0) (0 0) (0 6x) (0 0) (0 6) (0 0)” with period 2P = 8. But even this won’t work on the simulator!
Collapsed Beats
When every odd beat is guaranteed to have siteswap numbers (0 0), it is redundant to write it explicitly every time. We can therefore, condense the representation derived above:
- Eliminate the (0 0) written for the odd numbered beats.
- In the sequence that remains, each pair of round brackets now represents two beats, not one.
Effectively, we have “collapsed” two beats into one to finally arrive at the simulator compatible[5] version of the asynchronous siteswap sequence “3” juggled with the hand siteswap sequence “1 3”: “(6x 0) (6 0) (0 6x) (0 6)”. Table 5 captures this transformation. Note that in the “synchronous simulator” notation, only the even beats are indicated. The siteswap numbers (0 0) for the odd beats are implicitly assumed.
| Original Sequence | Synchronous Equivalent | Synchronous slowed | Synchronous Simulator | ||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| Beat | Siteswap Number | Beat | Siteswap Number | Beat | Siteswap Number | Beat | Siteswap Number | ||||
| Object | Hand | Object | Hand | Object | Hand | Object | Hand | ||||
| 0 | 3 | 1 | 0 | (3x 0) | (1 1) | 0 | (6x 0) | (2 2) | 0 | (6x 0) | (2 2) |
| 1 | (0 0) | (0 0) | |||||||||
| 1 | 3 | 3 | 1 | (3 0) | (1 1) | 2 | (6 0) | (2 2) | 2 | (6 0) | (2 2) |
| 3 | (0 0) | (0 0) | |||||||||
| 2 | 3 | 1 | 2 | (0 3x) | (1 1) | 4 | (0 6x) | (2 2) | 4 | (0 6x) | (2 2) |
| 5 | (0 0) | (0 0) | |||||||||
| 3 | 3 | 3 | 3 | (0 3) | (1 1) | 6 | (0 6) | (2 2) | 6 | (0 6) | (2 2) |
| 7 | (0 0) | (0 0) | |||||||||
Average Theorem and Permutation Test
The average theorem still works in the collapsed beat notation: just remember that if the sequence has P terms, it actually represents 2P beats, i.e., the period is 2P. So the number of objects in the corresponding juggling pattern is the sum of all the siteswap numbers divided by 2P.
For the permutation test applied to a collapsed beat pattern having P terms, the “Add” row gets modified as shown below.
| Current Time (in beats) | 0 | 2 | … | 2(P-1) |
|---|---|---|---|---|
| Siteswap Number | (2T0R 2T0L) | (2T1R 2T1L) | … | (2T(P-1)R 2T(P-1)L) |
| Add | (0 0) | (2 2) | … | (2(P-1) 2(P-1)) |
Only even numbers are added. Further, the modulus of the addition result has to be taken w.r.t. 2P. Finally, for a valid pattern, the Remainder Row must have all the even numbers from 0 to 2(P-1), as only even beat numbers exist in a collapsed beat sequence.
Transitions
We now present the collapsed beat equivalents for the asynchronous transition examples used in this blog. Observe that in Tables 7 and 8, when the hand siteswap used throughout is “2”, an odd siteswap number necessarily means a crossing throw. Likewise, an even siteswap number means a throw to the same hand. In other cases, we need to work out both the object and hand scheduling to figure this out.
| Beat | Original Sequence | Synchronous Equivalent | Synchronous Simulator | ||||||
|---|---|---|---|---|---|---|---|---|---|
| Siteswap Number | Throwing Hand | Crossing Throw? | Siteswap Number | Beat | Siteswap Number | ||||
| Object | Hand | Object | Hand | Object | Hand | ||||
| 0 | 3 | 2 | Right | Yes | (3x 0) | (1 1) | 0 | (6x 0) | (2 2) |
| 1 | 4 | 2 | Left | No | (0 4) | (1 1) | 2 | (0 8) | (2 2) |
| 2 | 2 | 2 | Right | No | (2 0) | (1 1) | 4 | (4 0) | (2 2) |
| 3 | 3 | 2 | Left | Yes | (0 3x) | (1 1) | 6 | (0 6x) | (2 2) |
In Table 7, at beat #2 of the original sequence, the hand and object siteswap numbers are equal (= 2), immediately suggesting a “hold”. However, this “hold” is not so obvious in either of the synchronous notations.
| Beat | Original Sequence | Synchronous Equivalent | Synchronous Simulator | ||||||
|---|---|---|---|---|---|---|---|---|---|
| Siteswap Number | Throwing Hand | Crossing Throw? | Siteswap Number | Beat | Siteswap Number | ||||
| Object | Hand | Object | Hand | Object | Hand | ||||
| 0 | 3 | 2 | Right | Yes | (3x 0) | (1 1) | 0 | (6x 0) | (2 2) |
| 1 | 5 | 2 | Left | Yes | (0 5x) | (1 1) | 2 | (0 10x) | (2 2) |
| 2 | 3 | 2 | Right | Yes | (3x 0) | (1 1) | 4 | (6x 0) | (2 2) |
| 3 | 5 | 2 | Left | Yes | (0 5x) | (1 1) | 6 | (0 10x) | (2 2) |
| 4 | 0 | 2 | Right | NA | (0 0) | (1 1) | 8 | (0 0) | (2 2) |
| 5 | 4 | 2 | Left | No | (0 4) | (1 1) | 10 | (0 8) | (2 2) |
| 6 | 1 | 2 | Right | Yes | (1x 0) | (1 1) | 12 | (2x 0) | (2 2) |
Again, as in Table 4, we have to double the period of the synchronous sequences by mirroring all the terms and appending them to the ones already derived to make them valid. Thus, the valid simulator sequence[6] becomes, “(6x 0) (0 10x) (6x 0) (0 10x) (0 0) (0 8) (2x 0)*”.
| Beat | Original Sequence | Synchronous Equivalent | Synchronous Simulator | ||||||
|---|---|---|---|---|---|---|---|---|---|
| Siteswap Number | Throwing Hand | Crossing Throw? | Siteswap Number | Beat | Siteswap Number | ||||
| Object | Hand | Object | Hand | Object | Hand | ||||
| 0 | 3 | 2 | Right | No | (3 0) | (1 1) | 0 | (6 0) | (2 2) |
| 1 | 3 | 3 | Left | No | (0 3) | (1 1) | 2 | (0 6) | (2 2) |
| 2 | 3 | 1 | Right | Yes | (3x 0) | (1 1) | 4 | (6x 0) | (2 2) |
| 3 | 3 | 3 | Right | No | (3 0) | (1 1) | 6 | (6 0) | (2 2) |
| 4 | 3 | 1 | Left | No | (0 3) | (1 1) | 8 | (0 6) | (2 2) |
Once again, we need to double the period using mirrored terms to get the valid simulator version: “(6 0) (0 6) (6x 0) (6 0) (0 6)*”. Also, the opportunity to “hold” at beats #1 and #3 (where hand and object siteswap numbers are equal in the original sequence) is again not obvious when looking at the synchronous notations.
| Beat | Original Sequence | Synchronous Equivalent | Synchronous Simulator | ||||||
|---|---|---|---|---|---|---|---|---|---|
| Siteswap Number | Throwing Hand | Crossing Throw? | Siteswap Number | Beat | Siteswap Number | ||||
| Object | Hand | Object | Hand | Object | Hand | ||||
| 0 | 3 | 2 | Right | Yes | (3x 0) | (1 1) | 0 | (6x 0) | (2 2) |
| 1 | 3 | 2 | Left | Yes | (0 3x) | (1 1) | 2 | (0 6x) | (2 2) |
| 2 | 5 | 2 | Right | Yes | (5x 0) | (1 1) | 4 | (10x 0) | (2 2) |
| 3 | 3 | 3 | Left | No | (0 3) | (1 1) | 6 | (0 6) | (2 2) |
| 4 | 5 | 1 | Right | No | (5 0) | (1 1) | 8 | (10x 0) | (2 2) |
| 5 | 0 | 3 | Right | NA | (0 0) | (1 1) | 10 | (0 10) | (2 2) |
| 6 | 4 | 1 | Left | No | (0 4) | (1 1) | 12 | (0 8) | (2 2) |
| 7 | 5 | 3 | Left | Yes | (0 5x) | (1 1) | 14 | (0 10x) | (2 2) |
| 8 | 0 | 1 | Right | NA | (0 0) | (1 1) | 16 | (0 0) | (2 2) |
| 9 | 4 | 3 | Right | Yes | (4x 0) | (1 1) | 18 | (8x 0) | (2 2) |
| 10 | 1 | 1 | Left | No | (0 1) | (1 1) | 20 | (0 2) | (2 2) |
| 11 | 3 | 2 | Left | Yes | (0 3x) | (1 1) | 22 | (0 6x) | (2 2) |
| 12 | 3 | 2 | Right | Yes | (3x 0) | (1 1) | 24 | (6x 0) | (2 2) |
Again, the derived synchronous sequence has to be completed by appending the mirrored terms to the sequence derived so far. Here, the opportunity to exploit the “hold” at beat #3 is obscured in the synchronous notation, but the opportunity to hold at beat #10 remains obvious in both the synchronous notations, the object and corresponding hand siteswap numbers being equal.
In Tables 7 and 8, the “original sequence” can directly be run on the juggling simulators since the hand siteswap is “2” throughout. But the simulator is not smart enough to understand that the “synchronous equivalent” sequence is reasonable in these cases as each hand is still throwing only on alternate beats. We must use the “simulator synchronous” version if we want to use synchronous notation and this runs at half the speed of the “original sequence” as each beat is now stretched to two beats. The simulator thus, cannot run the asynchronous and synchronous versions of the exact same sequence at the same speed without changing other settings[7]!
In Tables 9 and 10 on the other hand, the hand siteswap is such that the same hand has to (occasionally) throw on successive beats. In these cases, there is some merit in the simulator forcing the use of collapsed beats to ensure that each hand throws only on alternate beats. This aspect of simulator behaviour will be revisited in the context of transitions between asynchronous and synchronous sequences in the next part.
Footnotes
- I use juggling “state graphs” to work out how to transition between two sequences.
- Two popular juggling simulators are JoePass! (needs download) and Gunswap (browser enabled – thanks Karsten for pointing me to this).
- Juggling Lab uses customized extensions to the siteswap notation to represent such patterns. But consistency of the notation is lost due to such extensions. It also makes the notation more complicated.
- We can show that if the permutation test works for the starting sequence, then it’ll work for the resultant sequence after these operations.
- Most simulators expect a comma between the numbers in the round brackets.
- Most simulators use alphabets instead of double digit siteswap numbers: a = 10, b = 11, c = 12, etc.
- Simulators will typically have a “beat duration” (or equivalent) setting which can be used to run the pattern slower (and higher) or faster (and lower).