How To Use the Siteswap Generator

'J2' is a program to generate juggling patterns. In short, you give the program a list of parameters on the generator control panel, and then when you hit the "Generate" button it finds ALL patterns which fit the given constraints. Since the number of patterns can be very large, it is wise to have an idea of what kinds of patterns you want when you ask the program to do something.

In this version there are 3 basic modes, or types of patterns which can be found:

  • Solo asynchronous juggling ('siteswap' mode, the default)
  • Solo synchronous juggling
  • Two person passing
  • For an explanation of the notations used in each of these modes, refer to the notation instructions.

    Required Settings

    Three parameters are required by the program -- they are listed across the top of the siteswap control panel. These settings specify:

  • Number of objects juggled
  • Maximum throw value to use
  • Pattern length
  • Obviously, as any of these numbers increases the program will take longer to run, since there are more possibilities for the computer to consider. Consider the following example settings:

                     3 5 3     ->  A list of 3 object tricks including 441
                                   and 531.
                     5 7 1     ->  All we get is 5, the cascade.  There
                                   are no other valid tricks of length 1.
                     5 7 5     ->  A list containing many interesting 5
                                   ball patterns.
    In some of these runs several of the patterns printed will have portions before and after, separated by spaces from the patterns themselves. These are 'excited state' patterns, discussed in the siteswap notation documentation page. The throws to the left are starting sequences, those to the right are ending sequences. Use these throws to get in and out of the trick from the middle of a cascade. Any pattern without these throws before and after is a ground state pattern.

    Important: The throws in the starting/ending sequences are not parsed by the multiplexing filter, so they may require you to make 2 simultaneous catches from different places. The 'excluded throws' option doesn't apply either. See below for explanations of these terms.

    "Mode" Options

    This setting simply tells the program what types of patterns you'd like it to find. Each one has its own notation, as described on the notation page.

    "Find" Options

    This tells the generator what class of patterns to find: Ground state patterns, excited state patterns, or both. The "Starting/Ending Seq." option will print starting and ending sequences for any excited state patterns that are found -- otherwise '**' is printed to indicate an excited-state pattern.

    "Types" Options

    These options require some explanation. One general point about siteswap patterns is that two which are in the same "class" (meaning that they share the same starting and ending sequences) can be strung together to get another valid pattern. Thus since 441 is a ground-state 3-ball pattern, as is the cascade pattern 3, they can be put together to get another valid pattern: 4413. In this case we say that 4413 is a composition of 441 and 3.

    The other point is that you can rotate a pattern to get another valid one. Thus 441 can be rotated left to get 414. Note that 414 is not a ground-state pattern, as written, since in the following throw sequence:

             .... 3333333 414 414 414 ...
    the last 3 lands at the same time and place as the first 1.

    The program doesn't list all the rotated versions of the patterns that it finds, since this clutters up the listings too much. How does it decide which rotation to display? It displays the rotation which minimizes the length and throw values of the starting sequence. In the case of 441, this minimum starting sequence length is 0 if the pattern is displayed as 441 (not 414), so it's displayed that way.

    Now the three "Types" choices break down in the following way:

    Do not show patterns which are compositions of other, listed, patterns.
    Show all compositions. Thus 4413 and 3441 are listed.
    Show only "simple" patterns, which are those which are not compositions of any shorter patterns.

    An example might clarify: Consider the pattern 51414. This is actually a composition of two shorter patterns, 51 (the shower) and 414. When "simple" is selected for this option, 51414 will not be displayed because it's a composition. In the "default" setting, however, this pattern will be displayed because, although 51 is displayed as such by the generator, 414 will be displayed as its ground-state rotation 441. If you were looking at a table you would see 51 and 441 with different starting/ending sequences, and it wouldn't be obvious that you could rotate the latter and tack it onto the former. Because this is not obvious, these types of compositions are displayed as the default. (Actually, in this case the generator will list the pattern as its rotated version 45141, since this is ground-state.)

    "Multiplexing" Options

    Checking this item turns on multiplexing. By default the program does not find multiplexing patterns; this flag allows you to do so. The "# Allowed Throws" box sets the maximum number of throws you want any hand to make at any time; usually this will be 2, and very rarely more than 3. Higher numbers slow down the program a lot.

    Regarding the "Use Multiplexing Filter" option: When I first implemented the multiplexing option I noticed that most of the patterns found by the computer required the juggler to make 2 or more catches simultaneously with the same hand. This is doable if the objects come from the same place (a clump of 2), but it's really tough otherwise. Therefore I added a filter which gets rid of all multiplexing patterns which require the simultaneous catching of objects from 2 different places (unless one of the caught "throws" was a hold). It seems to be the case that virtually no popular multiplexing patterns require these simultaneous catches. Uncheck this box to eliminate this filtering, but be prepared for some whopping lists.

    "Exclude These (self) Throws"

    Enter throw values here which you do not want to appear in the listed patterns. Very low throws (like '3') are sometimes hard to do in a pattern containing other high ones. Excluding several throws also speeds up the program quite a bit. Write the throw values in normal decimal form (do not use the generator's 10='a' shorthand used in its output), with spaces between throws. As noted above, this exclusion doesn't apply to the starting and ending sequences.

    "Include These (self) Throws"

    All throw values specified here must be contained within each listed pattern. Enter them as above.

    "Exclude These Passes"

    In two-person passing mode, exclude passes with these throw values. Again, sometimes low passes are hard to do, and this lets you get rid of them. This flag has no effect when not passing. To enter, leave out the 'p' suffix which the generator prints.

    "Passing Communication Delay"

    This delay setting only has an effect when passing. If you are doing a standard ground state passing pattern (such as <3p|3p><3|3> for 6 objects), you and your partner can switch into any ground state pattern instantly, with no intermediate throws. However, many of the patterns printed will require you both to start throwing differently at the same time (you have to count down to the start of the pattern, to ensure synchronization). It is nice to allow for a communication delay, though, so that person #2 has time to react when person #1 starts throwing a trick (many of the popular passing tricks have this property). This is what this setting determines. The number you input is the number of throws after the beginning of the trick before person #2 needs to throw something different from what he was while doing a standard ground state pattern (like <3p|3p><3|3>).

    A few words need to be said about what constitutes a "standard ground state pattern". These are those patterns which are composed of ground state patterns of length 1. For 6 objects, for example, run the generator with the settings: (number=6, max throw=4, length=1, mode=passing, find=Ground). You get two ground state patterns of length 1: <3|3> and <3p|3p>. Any combination of these stuck together qualifies as a "standard ground state pattern"; these include standard two-count passing <3p|3p><3|3>, ultimate passing <3p|3p>, and so on. The delay flag lists all patterns which provide the requested communication delay for at least ONE of these "standard passing patterns". Whew, this is complicated.

    As an example, run the generator with settings: (number=6, max throw=4, length=3, mode=passing, delay=2) and the list includes the two patterns: (the guy in the left slot is the one "leading" the tricks)

                            which assumes the people were doing the
                            standard <3p|3p><3|3> before the trick was
                            being done.  Note that person #1 has to begin
                            when his partner is throwing a pass.
                            which assumes the people were ultimate
                            passing before starting the trick.
    Some of the patterns will require a 2-count passing pattern to get the requested communication delay, others a 3-count, and so on. When you use this feature just scan the list for the patterns relevant to your case.

    As a final example, run the generator with settings: (number=6, max throw=3, length=3, mode=passing, multiplexing=on, # allowed throws=2, delay=3). One of the patterns is the popular "left-hand single" multiplexing pattern: <2|3p><2p|3><[3p2]|3p>. Note that the communication delay setting has vastly reduced the number of tricks.

    "Passing Leader Slot Number"

    For use with the delay setting above. This sets the person who is the "leader". The default is person #1, whose throws are printed in the left position of each < | >.