@DATABASE "NOTATION" @NODE MAIN "NOTATION" NOTATION USED BY THE J2 PATTERN GENERATING PROGRAM -------------------------------------------------- Jack Boyce (jboyce@tybalt.caltech.edu), 12/91 This file describes the system used by the program @{"J2" Link "j2.guide/MAIN"} for notating juggling patterns. For a solo asynchronous juggler, this just reduces to the popular 'site swap' notation; if you are familiar with this you can skip down to the MULTIPLEXING section below. If not, just read on. This documentation was originally written from Jack Boyce. It was converted to notation.guide by Werner Riebesel in 5/96 with no changes in the text except for the added links. @{" TABLE OF CONTENTS " Link Table_Of_Contents} @{" GENERAL IDEA " Link 1.} @{" SOLO ASYNCHRONOUS JUGGLING " Link 2.} @{" GROUND STATE/EXCITED STATE PATTERNS " Link 3.} @{" MULTIPLEXING " Link 4.} @{" SOLO SYNCHRONOUS JUGGLER " Link 5.} @{" TWO PERSON PASSING " Link 6.} @{" LEARNING PATTERNS " Link 7.} @ENDNODE @NODE Table_Of_Contents " TABLE OF CONTENTS " MAIN@{" NOTATION " Link MAIN} 1.@{" GENERAL IDEA " Link 1.} 2.@{" SOLO ASYNCHRONOUS JUGGLING " Link 2.} 3.@{" GROUND STATE/EXCITED STATE PATTERNS " Link 3.} 4.@{" MULTIPLEXING " Link 4.} 5.@{" SOLO SYNCHRONOUS JUGGLER " Link 5.} 6.@{" TWO PERSON PASSING " Link 6.} 7.@{" LEARNING PATTERNS " Link 7.} @ENDNODE @NODE 1. "GENERAL IDEA" 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. This program uses a very 'compact' system, for two reasons: (1) it makes the notation more amenable to computer analysis, and (2) with less "superfluous" information in the notation it is easier for a person to look at a pattern and figure out how to do it. The main limitation of the notation used here is that it ignores all information concerning throwing and catching positions, as well as any characteristics about the objects being juggled (number of spins on clubs, etc.). When an object is thrown, the ONLY things this notation tells you are which hand to throw to, and the amount of time until the object is caught and thrown again. You have complete freedom in choosing how these should come about: 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 winds up at the right place in the right amount of time. The notation's ignorance of these throwing styles means that tricks like the 3 ball cascade and Mills' Mess are lumped together, but if you apply some creativity to the output of the program you can get most tricks that people do, and many that have never been done before. Next item: @{"SOLO ASYNCHRONOUS JUGGLING" Link 2.} @ENDNODE @NODE 2. "SOLO ASYNCHRONOUS JUGGLING" ('site swap' notation) 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 our 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. The patterns that the program generates are just sequences 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. Valid 3 ball tricks include: 3 = standard cascade 51 = shower (that's 5 and 1, not fifty-one) 42 = two in one hand, hold with the other 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 2 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 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 3 in one hand, the other hand empty). 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 comprises a valid pattern. '76' doesn't work, but '75' is a valid 6 ball pattern (commonly known as the 6 ball half-shower). Not all strings of numbers with the correct average are valid patterns, however. Next item: @{"GROUND STATE/EXCITED STATE PATTERNS" Link 3.} @ENDNODE @NODE 3. "GROUND STATE/EXCITED STATE PATTERNS" The site swap patterns described in the previous section can be grouped into two categories. Any pattern that can be started directly from the middle of a cascade (or fountain, for even numbers) is called a 'ground state' pattern. One which does not have this property is termed an 'excited state' pattern. In the list of 3 ball tricks above, all of them are ground state patterns with the exception of 51, the shower. To switch from the cascade into the shower you have to go through a series of intermediate throws in order to avoid getting two balls in a hand at once. For the shower, a valid starting sequence of throws is '52' (note that this is not a valid repeatable pattern, by the average rule). Switching from the cascade to the shower and back again we could go: ...33333333 52 515151...5151 2 3333333... We say that '52' is a valid starting sequence for the excited state site swap 51, and '2' is a valid ending sequence (gets you back into cascade). The starting and ending sequences are in general not unique. Next item: @{"MULTIPLEXING" Link 4.} @ENDNODE @NODE 4. "MULTIPLEXING" If we allow 2 or more throws to be made at the same time by a single hand, the simplest way to notate it is to group together with brackets the throw numbers of the multiplexed throws. For example, a 5 ball ground state multiplexed pattern is: 24[54]. From the middle of a cascade (no starting sequence is needed, since this is a ground state pattern), 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 2 balls in it, since it did the hold first). Then we can either switch back into the cascade, or repeat the trick with a left-handed hold, etc. (since the pattern is of odd length it switches hands each repetition). [This, by the way, is a trick that Anthony Gatto does in his act, except that he does it all while juggling over his head. He can also do 26[76] with 7 balls.] Next item: @{"SOLO SYNCHRONOUS JUGGLER" Link 5.} @ENDNODE @NODE 5. "SOLO SYNCHRONOUS JUGGLER" If both hands are throwing at the same time, the notation is very much like site swap notation above, but with two differences: (1) group together throws made simultaneously with parenthesis, and (2) now we 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 site swap notation above: a short pass from hand to hand. A '0' is still no throw, and a '0x' is not allowed. ALL throw numbers now must be even. Examples of simultaneous patterns: (4,4) = 4 ball simultaneous fountain (4x,4x) = a common crossing version of the 4 ball fountain (4x,2x) = 3 ball shower with synchronous 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 fountain (1 missing) You are free to choose which hand corresponds to which slot in the parenthesis, but your choice must remain consistent throughout a given pattern. Lastly, multiplexing can be notated exactly as above; for example the 4 ball pattern (4,2)(2x,[44x]) has a multiplexed '4' and '4x'. Next item: @{"TWO PERSON PASSING" Link 6.} @ENDNODE @NODE 6. "TWO PERSON PASSING" Imagine two people juggling, each person asynchronously, but synchronized with respect to each other (person 1 throws with his/her right hand at the same time person 2 does). This is the situation in 6 club passing, for example. Now our notation has to tell BOTH people what to do, which might sound complicated but actually isn't too bad. Divide a "throw" into 2 parts, the throwing instructions for each person. A self-throw is written just as a number, exactly as we did for site swap notation (a 2 is a hold, a 3 is a toss to the other hand, etc.). Attach 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. Some example patterns should help clarify this: <3p|3p><3|3> = ordinary 6 object passing. Notice how the instructions for each person are sectioned off Each person starts t hrowing with his right. <3p|3p> = "ultimate" passing, where all throws are passes <3|3> = two people doing 3 ball cascades (boring) <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). This is a ground state trick, so no starting sequence is needed. <2|3p><2p|3><[3p2]|3p> = a multiplexed pattern, the left-handed single (a good way to fake out your partner). 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. Next item: @{"LEARNING PATTERNS" Link 7.} @ENDNODE @NODE 7. "LEARNING PATTERNS" The ability to pick up site swaps quickly is very much an acquired skill. At first stick to ground state tricks, since you can do a single repetition of these from within a cascade/fountain. When you get good at this you can try to "run" a trick, that is, do it continuously without switching back to the cascade/fountain. After a while you figure out which kinds of tricks are easy and which are hard (a lot of high throws, for example, are tough). To practice excited state tricks you usually just have to "go for it" and try to run it. At any rate, after some practice it becomes substantially easier to learn new patterns, and this is when it becomes really fun. Multiplexing tricks are fun because many of them don't involve high throws, which makes them easier to do. Hence you can learn a lot of tricks and variations without a ton of work. The important thing here is to practice the combination throws; for example when you learn '24[54]' you will find that your weak point is the combination '[54]'. Some combination throws, especially those involving both very high and very low throws (except when the low throws are holds), can be really tough. '[71]' or '[93]' are extreme examples. @ENDNODE