From: ecarsten@next1.cs.umr.edu (Edward Carstens)
Newsgroups: rec.juggling
Subject: Re: Site swap vs. MHN
Date: 15 Oct 92 15:28:03 GMT
Article-I.D.: umr.1992Oct15.152803.18034
Organization: University of Missouri-Rolla, Missouri's Technological University

In article <9210150158.AA03195@usma6.usma.edu> x47377b2@usma6.USMA.EDU  
(Pritchard Sean CDT) writes:
> I'm still confused about all this talk about Site swap notation and Multi  
hand
> notation.  What programs use this notation and where are they available?   
What
> are the limitations of each.  Which is easier to use?  Which, overall, would
> you recommend.  I guess it's time for me to emerge from the dark ages of
> juggling.  I've been learning from arcane sources such as books and oral
> tradition.  Into the electronic age...

JugglePro is based on MHN but is able to convert other notations to MHN such as  
siteswap, sync notation, multiplex notation, and customized notation.  I have  
included notation.doc written by Jack Boyce for your reference.  It is in my  
opinion one of the best written explanations for siteswaps and sync notation  
and even has a way of describing multiplexing within either notation.  Even if  
you already know it all I recommend reading this and playing with his  
generator, J2, which is available via ftp from piggy.cogsci.indiana.edu.  (You  
will also find it incorporated into JugglePro.)

Naturally I am biased toward JP, but other viewers exist that take advantage of  
siteswap notation:  juggle (Allen Knutson), xjuggle, juggle! (Michael Kramer),  
and jug (Hawtin).  All except juggle! are available via ftp.

Siteswap is the simplest notation, yet it is limited to asynchronous throws.   
Synchronous notation was developed specifically for individual synchronous  
throwing patterns (such as the 3-ball box or see-saw).  MHN was developed to  
mathematically represent any periodic pattern with any number of hands and a  
nice even rhythm.  Siteswaps and sync individual can all be represented in MHN.   
The disadvantage is a pattern in MHN must be written down -- it is difficult to  
describe verbally to someone because it is a matrix of vectors.

________________________________________________________________________
            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 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.


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.


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.


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.


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.]


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'.


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 throwing 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.


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.
Newsgroups: rec.juggling