IJDb ...
Resources ...
Community ...
Search ...
Yet Another Tweaked Form of Siteswap
Contents
- Getting Started
- Simultaneous Throws
- The Active Hand
- Landing Modifiers
- Order in Multiplexes
- Rules to Remember
- Seeing it Work Together
- Non-Alternating Hand Rhythms
- Polyrhythmic Patterns
- Transitions Between Synch and Asynch
- Some State Graphs
- The End is Near
Getting Started
Siteswap is an ingenious way of notating the order of objects in a juggling pattern. It is simple, elegant and even intuitive. These statements of course refer to the most basic of siteswap, the vanilla siteswap. As siteswap only covers some aspects and types of a real world juggling patterns, it is natural to try and extend it to include more of them. Once some of these features are added to the system, things tend to become complicated. Let's go back and look at some of the basic assumptions made about vanilla siteswaps and define ways to deviate from them. We find that doing so allows us to explore the connections between vanilla, synchronous and multiplex patterns. We are also able to define these important extensions in a simple way. The notation described will at first look a little odd, but it will (almost) come back to the conventional way of writing these patterns. Keep in mind, that though Juggling Lab is used to animate the examples, it does not quite use the same notation.
Simultaneous Throws
One of the assumptions we make in reading a vanilla siteswap, is that each
throw is made on its own beat. This means that each written symbol hides behind
it the command to allow time to pass before processing the next symbol. Such an
assumption begs to be tweaked, so we define the symbol ! to roughly mean "the next
throw is made on the same beat as the previous one", which can now be used to ignore
this assumption. This exclamation mark is probably easiest read as "and" in a pattern.
The familiar four ball synchronous fountain can now be written as 4!40. Comparing this
to the pattern's usual representation (4,4),
we see that usually synchronous throws are written in parentheses and the following
beat is assumed to not have any throws, meaning that synchronous patterns only notate
every other beat. Using ! we are also able to write patterns without this restriction.
Another form of simultaneous throws are multiplexes. These are throws made by a single hand and are usually written in brackets, but they are a little harder to discuss before considering how the throwing hand is determined in general.
The Active Hand
A vanilla siteswap makes no assumptions on which hands are juggling, but to juggle
a pattern a juggler must do this. First the juggler chooses which hands (or other manipulators)
will be used to juggle the pattern and then connects each throw in the pattern with one of
these hands. A two-handed version of a vanilla siteswap will usually alternate the hands
throwing. Another way of saying this is that each symbol hides behind it the command to
switch the hand that will make the next throw. Now, here again is an assumption we can
tweak, so we define the symbol * to roughly mean "the next throw is made by the same
hand as the previous one". This asterisk can be read as "star" though something like "switch" also works.
This definition expands on the established use of * in synchronous patterns,
where it has meant "repeat on the other side". As the end of a pattern already
contains the command "repeat", it's sufficient for * to mean "on the other side"
(in two-handed patterns of even length). Consider the pattern (8,4)*. Conventionally we first
write it out as (8,4)(4,8) and then assume this to be repeated as (8,4)(4,8)(8,4)(4,8)... Now,
another way to notate this same pattern is to insert a * and switch all the pairs of throws that
come after it: (8,4)*(8,4)(4,8)(8,4)... Repeating this process we get
(8,4)*(8,4)*(8,4)(4,8)... and eventually we get (8,4)*(8,4)*(8,4)*(8,4)*...
which is clearly a repetition of (8,4)* as intended. Patterns of odd length are by default not repeated
on the same side, but using a * allows this.
We can now give a definition for the conventional synchronous notation:
all throws written in parentheses are considered to have the symbol ! between them
and after the closing parenthesis, the symbols *0 are implied. (If only a zero was implied at the end,
the wrong hand would be throwing the next throw.) A comma can be used to separate throws for easier readability.
Using this rule, we can remove the parentheses in (4,4) to see that it is another form of 4!4*0
(which is also the same as 4!40*, and in this case the same as 4!40). Determining the throwing hand is kept
independent from the timing of the throws. So in a transition from asynchronous into
synchronous throws, the last throw before the first parenthesis is not the same hand
as the first throw in the parentheses. In the same way for a transition in the other
direction, the last throw in the parentheses is not the same hand as the first throw
after the closing parenthesis. A * can naturally be used in either case to indicate the
opposite to be true.
As for multiplexes, they also have an alternate way of being written: all throws
written in brackets are considered to have the symbols !* between them, except when
they are contained within parentheses, when only the * is needed. So [54] is equivalent
to 5!*4 and [543] is equivalent to 5!*4!*3. ([42],6) translates first into the odd-looking
(4*26) and results in 4!*2!6*0, though for two hands this pattern can also be written
as the more elegant 4!6!20.
So, did you notice that the synchronous examples so far have not had any crossing throws? Let's tackle this aspect next.
Landing Modifiers
In a two-handed vanilla siteswap where the throwing hands alternate,
odd throws switch hands and even throws don't. We take this as a definition
for which hand is supposed to catch a ball even in more complex patterns.
When we want to deviate from this, an x is attached to the throw. Since
synchronous patterns mostly consist of even throws, these patterns will use
x's to indicate a crossing throw. Odd throws with x's do not switch hands
and they are needed less often, mostly in patterns with a rhythm change.
In a way this definition can be used to determine which hands are
throwing and when. Since we have already defined this in the previous
section, it might seem that there are cases where these concepts conflict.
If this happens, the simplest thing to do is to consider the pattern incorrectly
written or invalid. For example, 441* or 4x4x1x are not written correctly
because it is not clear which of the patterns 441 or 4x4x1x* is meant.
Unfortunately, in many cases the standard way of writing transitions
between synchronous and asynchronous rhythms are also written incorrectly
by this criteria. For example, the transition ...(4,4)(4x,5)(4x,5)5353...
is the incorrect version of ...(4,4)(4x,5)(4x,5)*5353... while returning on
the other side ...(4,4)(5,4x)(5,4x)5353... is the correct version compared to
...(4,4)(5,4x)(5,4x)*5353... To avoid incorrectly writing patterns,
remember that any two consecutively written throws are made by different hands,
except when there is a * between them.
So why have two ways of defining things? Isn't it enough that the state contains the
information to determine which hand is supposed to throw? Isn't the * a
little redundant in these transitions? The answer is no, as the * helps
clarify the pattern. As transitions like this remain more complex than average practical
pattern, and considering that normal jugglers are easily perplexed by them, it wouldn't hurt to clarify
this aspect of siteswap a little bit. By contrast, next we consider something that will
most likely add confusion for the average juggler.
Order in Multiplexes
Finally I'd like to suggest a rule for distinguishing between multiplexes
containing the same throws. In practical juggling there most often isn't a need
to do this, as the patterns created are very similar. However, on the theoretical side
of things, these can be seen as different patterns. As an example, using separate colored balls one can notice
that the pattern [54]24 can be juggled in two different ways. One of these can be
split into the orbits 504 and 420, while the other version contains all the balls
in a single orbit. It would be natural to call one of these [54]24 and the other [45]24,
but which is which?
When actually juggling patterns like these, the difference seems to be how the balls are caught before the multiplex and the throws themselves are similar. With this in mind, it would be nice for the order of the throws in the multiplex to correspond to the order in which they were caught, but this doesn't work since throws can be caught simultaneously. The next best thing is to look at how 'high' the balls were last thrown and use this order instead. Once this is done, the balls available to be thrown are assigned to the throws within a multiplex in the order that they were previously thrown. This roughly means that the first number in a multiplex will be the ball that was last thrown the highest, and so forth. To be precise, we add that if previously two balls were thrown simultaneously, the throw that was written first is considered higher.
Thus, to answer our previous question, 504 and 420 combined is
[54]24, while
[45]24 has only one orbit. 303 and 420 combined is
[34]23. 606 and 720 combined is
[67]26. 501
and 411 combined is
[54]1[11]. (6x,4)(0,2x) and (6,0)(2,0) combined is
([66x],4)(2,2x), while the mirrored (4,6x)(2x,0) and (0,6)(0,2)
combine to make
(4,[6x6])(2x,2). Extreme examples include 531 + 423 =
[45][23][13] and 615 + 534 =
[65][13][45], which probably are only useful for viewing in
a simulator. (Since currently no simulators use this exact rule to handle these differences, to view other examples some guesswork might be needed.)
Obviously we can still use the more familiar form of writing the throws in
a multiplex in descending order, whenever there is no need to highlight the
different patterns. As a curiosity, it is possible to devise a notation that
uses this rule to determine in which hand each ball is caught, instead of
attaching x's to throws. As this isn't really a practical goal, we'll leave
the handling of this to those that have too much spare time. The rest of us
can move on to making a few observations on how these rules work together.
Rules to Remember
The three symbols !, * and 0 do not require any throws to be made, so if
any of these appear in succession, changing their order does not change the
throws and hence the actual pattern stays unaltered. In addition, when they
all appear once, they cancel out each other's effects, so that 0!* can be
inserted or deleted anywhere in a pattern without changing it, as can all
of its permutations. Assuming the use of two hands, a * by itself has the
same effect as 0! or !0, so ** can also be added or subtracted without
consequence. These operations are sometimes useful when trying to figure
out the clearest way to write a pattern.
Consider the pattern 4!2x0. It is a three ball pattern, because it
has a period of two beats and the throw heights sum to six. It contains
three symbols that change which hand is throwing next, so for two hands
the starting hand alternates as the pattern repeats. What is a more familiar
notation for this pattern? In order to add parentheses, the pattern must
contain the two symbols *0, so *0! is added into 4!2x0 to get the equivalent
notation 4!2x*0!0. The *0 is discarded as the simultaneous throws are placed
in parentheses to get (4,2x)!0. For two hands this pattern is (4,2x)*, the familiar
form of The Box. Similar transformations of the patterns 4x!20, 4!2*0, and 2x!4x0* are good for comparison.
The exclamation mark ! can be used after a pair of synchronous throws
to mean "there is no empty beat here", in the way Juggling Lab applies it.
For some throws A and B, (A,B)! is the same as A!B*0! from which the *0!
cancels out and leaves A!B, a simple synchronous throw without an empty beat
after it. Any synchronous throws can thus be written in parentheses for clarity,
including ones that aren't followed by a zero. It often is clearer to not use !
when possible, but it can't always be avoided. A held 1x will often be in the
last pair of synchronous throws before transitioning into an asynchronous rhythm
and this will require an ! to be used. For example, a transition from (2,4)
into 441 is (1x,3)! or 1x!3, whichever notation is preferred,
but in either case the ! is needed. When the ! is required, it is arguibly clearer
to write the version with parentheses, though often the version without them is shorter. As an example of this, the
correct notation for a transition from (2,4) into 3 is simply 1x! and
from (4,2) it is *1x!, whereas the respective versions with parentheses are (1x,3)!
and (3,1x)!*.
One more rule to know is that within a pattern using two hands the string *(A,B)*
is equivalent to (B,A) where A and B are some throws. This is not quite the same
thing as saying (8x,4x) and (4x,8x) represent the same pattern, but rather that
(8,4)*(8,4)* and (8,4)(4,8) are the same, as was already demonstrated.
Seeing it Work Together
For the remainder of this article, we'll present some examples of patterns that make use of the notational devices that have been discussed. This first interesting routine contains most of these ideas, so understanding it should serve as a good exercise.
5354x1x(4,4)(4x,5)(4x,5)*5354x54x0(4,4)(5,4x)(5,4x)535354x1x*(4,4)(4x,5)(1x,5)!353 RLRL R (L,R)(L ,R)(L ,R)*RLRL RL R(L,R)(L,R )(L,R )LRLRLR L *(L,R)(L ,R)(L ,R)!LRL 0123 4 5 5 7 7 9 9 1234 56 7 8 8 0 0 2 2 456789 0 1 1 3 3 5 5 678 ADCB D A D C B A D CBAC BC A D B C A D CBDABC A A D C B A D ACB
Here the second row indicates which hand is making each throw, the third row keeps track
of the beats, and the fourth row names the balls that are used so the orbits are easy
to follow. Writing these things out often helps understand how an unfamiliar pattern
works. This four ball pattern starts with a right-handed half shower and then transitions
into a synchronous fountain and back. Then it does so again, but returns into a left-handed
half shower instead. With one more set of transitions, the pattern returns to the beginning.
Notice that in all the sections with synchronous throws, the left hand is written first in
the parentheses. This makes the pattern slightly easier to read and couldn't be done without
the * before the last synchronous section. (Juggling Lab also normally preserves the hand
order in parentheses.) An alternate way of writing the last transition is (4x,5)1x!
instead of (4x,5)(1x,5)!3, but it can't be written correctly without the exclamation mark.
Writing this pattern without parentheses looks like this:
5354x1x4!4*04x!5*04x!5*0*5354x54x04!4*05!4x*05!4x*0535354x1x*4!4*04x!5*01x!5*0!353
Which can be further transformed into a shorter (though harder to read) version:
5354x1x4!405!4x04x!505354x54x0*4!405!4x04x!50535354x1x4!404x!50*1x!5353
Non-Alternating Hand Rhythms
In passing patterns, hurries are throws that are made by a hand that is not
supposed to be throwing. Usually an asterisk * in this context means "the previous
throw was a hurry", whereas by our definition it means "the next throw is a hurry".
Hurries for a single juggler essentially mean patterns with a non-alternating
hand rhythm. These patterns require a hand to make two consecutive throws and
the easiest way to do this is when one of them is a hold or an empty hand, or
if the pattern is juggled relatively slowly.
4x4x1x* - a galloped cascade
|
4x4x4x0* - a low three ball flash
|
750* - a galloped four ball half shower
|
(6x,4x)(6x,4x)(7,4x)(7,5)(1x,1x)!short pause in a five ball half shower |
More similar patterns are easily found by adding a * after any 0 or 1
in any vanilla siteswap and then adding x's where needed. These patterns
will have vanilla counterparts where the pause is two beats and not one,
such as 5520, 55500, 9700 and (6x,4x)(6x,4x)(8x,4x)(8x,6x)(2,2) for the
examples given. Though these latter versions might suffice in communicating the pattern, the former versions can emphasize
the intended timing in the pattern more accurately and keep the heights of the throws more intuitive. Of course these are
not the only types of non-alternating rhythms, as more are found in the next section.
Polyrhythmic Patterns
Polyrhythmic, or multi synchronous, patterns are ones where the manipulators juggle at different, yet constant rates. These are a subset of patterns with a non-alternating hand rhythm. For example, it's not too difficult to juggle two balls in each hand with one hand making three throws as the other only does two. The simpleness of the idea is part of the beauty in these patterns, but this is easily lost in any notation of the patterns. The following examples are two balls juggled in each hand at the indicated ratio of throws per hand.
3:2 is (4,6)4640
4:3 is (8,6)0680*60*8600
5:3 is (a,6)060*a60*06a0*600
5:4 is (8,a)008a008*0a0*800a8000
The "height" requirements in these patterns are a bit misleading, because the beats are meant to be faster than
normal. The focus should rather be on the intervals between each throw since this is the aspect we want to notate
clearly. One could also try to notate the appropriate dwell times for each hand by catching the throws a little
earlier, but this again makes the pattern harder to read. So (4,6)4640 could be written as
(5x,4)(1x,4)!5x41x*. Other ways of writing this pattern include 4!60*4640,
6!404640*, 4!5x01x!45x41x, and (5x,4)!(0,0)!(1x,4)!(5x,0)!(0,4)!(1x,0)!.
The above patterns are quite basic and there are naturally many more that incorporate these same throwing rates. To get an idea of some other patterns, here are a few examples:
2:3 with four balls,(6x,4)(1x,3)!54x1x* or4!6x01x!354x1x or(6x,4)!(0,0)!(1x,3)!(5,0)!(0,4x)!(1x,0)!
|
2:3 with five balls,(5x,6)(1x,6)!5x61x* or6!5x01x!65x61x or |
2:3 with six balls,(8,8)(1x,4)!861x* or |
2:3 with five balls,(6,8x)4x750
|
2:3 with six balls,(8x,6x)7960
|
2:3 with seven balls,(8,9x)89x80
|
4:3 with five balls,(8,9x)09b0*60*ax700
|
4:3 with five balls,(cx,9x)05ex0*ax0*7300
|
a mix between 2:3 and 3:5 |
The last pattern uses dwell changes for transitioning between the rhythms 2:3 and 3:5, so that all throws are made to the same height. Very complex patterns can be constructed by switching between different throwing rates.
Transitions Between Synch and Asynch
Many times the problem in writing a pattern comes down to not knowing the exact throw heights,
and a subset of this problem is finding a valid transition between two patterns. A typical example
is wanting to transition between 744 and (6x,4)*. Here one needs to
examine how the balls are landing in 744, that is its state, and how they are
supposed to land before being able to start (6x,4)*. A working transition is 8x5x41x*
(or 8x5x41x(4,6x) if you prefer writing it without the
star). Going back it's possible to use (7,5x)(4,1x)!* and returning to the
other side is (6x,4)(5x,7)1x!4 or its equivalent (6x,4)(5x,7)(1x,4)!.
Starting from a different state we find a shorter transition,
going from 474 with 5x6x1x into (4,6x)* and back again with
(5x,7)1x!. The resulting pattern is shown in the animation to the right. In general, finding
a good transition and figuring out the correct notation for it does take some effort.
A more detailed method for doing this can fill an entire article, so here we can only present some examples
of how these transitions are written. The notation is color coded to show how each pattern splits up into
repeatable parts and transitions between them.
24
1x
(4,2)
(4,1x)!
|
3
4x1x
(4,2x)*
(4x,2x)1x!
|
3
41x
(4,4)(4,0)
*1x!
|
441
41x
(4,4)(4,0)
(2x,4)1x!
|
441
41x
(4,2x)*
1x!
|
534
54x1x
(4,4)
(5x,4)(1x,4)!
|
4
741x
(2x,6x)
(2x,5x)*1x!
|
4
556x16x1x
(2x,6x)
(5,6x)1
|
741
6x1x
(2x,6x)*
(2x,5)(6x,4)*
|
46
5x61x
(4,6)
(5x,6)(1x,6)!
|
717
6x16x1x
(4,6x)*
(6x,7)(1x,7)!
|
[54]24
[54]22[4x4][1x1x]
(2,[4x4])*
(2,[54])([1x1x],4)!
|
[52]3
[6x2]3[6x2]1x([6x2],4x)
(6x,4x)
(6x,3)(1x,3)!
|
5[32]
5[4x2]1x([4x2],6x)([4x2],6x)
(4x,6x)
(4x,5)(4x,5)1x!
|
[54][22]2
[4x4][1x1x]
(6x,[4x4])(2,4x)*
(2,[54])([1x1x],2)!
|
97531
ax76x3
(2x,0)(a,8)(6,4)*
(2x,0)(9x,8)(5x,4)*1
|
5
696
91
1x
(2x,8x)
*1x!
37
4x1x
(4x,6x)
(5,6x)*1x!
|
6
7x67x61x
(6,6)
(7x,6)(7x,6)(1x,6)!
|
75
76x76x1x
(6,6)
(7x,6)(7x,6)(1x,6)!
|
75
76x76x1x
(6,6)
(6,7x)(6,7x)(6,1x)!*
|
864
9x65x81x
(4,8)*
(4,9x)(6,5x)*1x!
|
567
6x7x8x1x
(4,6x)(6,8x)*
(4,6x)(6,9)(6x,4)(8x,6)1x!
|
7
6x722[22][1x1x]
([65x4],[65x4])(6x,0)(2,2)!(1x,1x)!*
([753],[8x6x4x])
|
966
ax7x6961x
(6,8x)*
(7x,9)(8x,6)1x!
|
Some State Graphs
As a final application for these notations, let's look at a couple of state graphs.
State graphs or state diagrams are a visual representation of how the state in a pattern
changes and repeats. Useful state graphs tend to be overly complicated to draw out in full,
and it's easier to draw a simplification of some sort. This first picture shows the
synchronous state graph for two balls and throw heights zero, two and four. The nodes
in the graph represent states and the arrows represent throws from that state. The
arrows are labeled with the different throws needed to get from one state to another.
If two states have arrows going back and forth between them, only one line is drawn
and the labels for both arrows are placed closer to the originating state, to the left of the arrow. To construct
a valid juggling pattern, simply find a cycle in the graph and then for each arrow take
one of the labels and string these together. Any cycle in the graph and any choice of
labels from each arrow in the cycle forms a valid juggling pattern. For example, visiting
each state in the graph clockwise yields the pattern (4,2x)(4x,0)(2,0) or
(2,4x)(4x,0)(2,0). The first label on the loop of the ground state is simply
a star. This obviously doesn't form a pattern by itself, but it can be used in other
patterns to switch which hand corresponds to the upper part of the state, decreasing the
number of states needed in the graph
As two ball synchronous patterns aren't very interesting in general, this previous
graph is more practical after a transformation into the four ball version on the left. Here is the
synchronous state graph for four balls using throw heights two, four and six. As an
additional simplification in this graph, pairs of throws that are siteswaps of each
other are left out, so (6,4) and (4x,2) are written explicitly
but (4x,6x) and (2x,4) are left out.
The final graph below shows the three ball patterns with throw heights less than five. This time every beat is shown, so this graph can be used to find some transitions between synch and asynch three ball patterns. Perhaps I'll return to discussing (and drawing) more state graphs at some point, but for now I'll leave this as just a glimpse of how these notations can be used in state graphs.
The End is Near
In this article, I have tried to connect the different types of siteswap notation to each other in a coherent way. Most of this has just been explicitly stating some hidden assumptions about siteswap and then defining simple ways to deviate from them. More extensions and clarifications can yet be considered, such as passing patterns and body throws, but the notation easily gets cluttered and loses some of its elegance. I hope the notational devices described here don't cross that boundary, but can help in more precisely communicating juggling patterns and maybe be of other practical use. A juggling simulator or notation translator that supported these notations would be a next natural step to take in this direction. For now I hope you have enjoyed the examples and can take some time off to go juggle. Have fun!