Juggling

Going from one pattern to another

A pattern is not just a sequence, it is a state: which of the next few beats already have something falling into them. Two patterns with the same object count can always be joined, but usually not immediately – you have to throw something in between. This finds the shortest way, by breadth-first search over states.

Where the usual test stops being right

Almost every description of siteswap gives one test: a sequence s0…sn-1 can be juggled exactly when i → (i + si) mod n is a permutation of Zn. That is correct, and it is what this app shows you for an asynchronous pattern. It is also exactly as general as its own wording, which is narrower than it looks:

• It is not a second condition that the average is a whole number. If the map is a permutation then the landing sites are a complete set of residues, so their sum is fixed modulo n, so the digit sum is divisible by n. The integer average follows. It does not work the other way: 543 averages to 4 and all three of its throws land on the same beat.
• It gets synchronous patterns wrong. The box, (4,2x)(2x,4), is a real three-object pattern with its own encyclopedia article. Its digits are 4, 2, 2, 4 – and 4224 fails the permutation test. Over the 14,762 synchronous patterns this build enumerated, the test applied to the digit string gets 1,484 of them wrong.
• It is not even well-typed for multiplex. When a hand throws two objects at once there is no single si to add to i. Collapsing the multiplex to one of its values does not rescue it: over 9,723 enumerated multiplex patterns there are 684 where no choice of collapse gives the right answer.

A published rule that does not survive being enumerated

For synchronous patterns there is a second published test: convert the pattern into two ordinary asynchronous sequences by the slide property, and put both through the permutation test. The formula as printed builds the second sequence by taking each value from the neighbouring throw while taking the decision of whether to shift it by a beat from its own throw's crossing flag. Both readings reproduce the one worked example the source gives, (8x,4x)(4,4) becoming 9344 and 5744, because in that example the two throws of each pair happen to carry the same flag.

Enumerating all 14,762 synchronous patterns of one and two pairs separates them. Read literally, the published formula rejects six patterns that can in fact be juggled – every one of them a pattern containing a 0 opposite a crossing throw, where the formula subtracts one from the zero and produces a throw of −1. (0,2x)(2x,0) is the smallest: one object crossing back and forth between the hands, which is perfectly juggleable. Taking the flag from the throw the value comes from instead fixes all six and disagrees with the simulation nowhere. This app uses the general test below and treats the slide property only as a cross-check.

The general statement that does cover all three is a bookkeeping one, and it is the one this app actually uses: a pattern can be juggled exactly when every hand, on every beat of the repeating cycle, catches as many objects as it throws. That is equivalent to the published criterion that the pattern's state transitions form a cycle in the state diagram.

Rows in the published list that do not survive their own rule

The encyclopedia's list of siteswaps prints an object count and a period for each pattern. These six rows disagree with the average rule stated in the same article, and this engine recomputes them:

The wikitext of that list also carries visible vandalism, which is why none of this app's catalogue is seeded from it.

What this is

An independent reimplementation, written from published descriptions of the notation and of juggling physics. It is not a copy of any existing juggling program and it contains no code from one. Juggling Lab, Jongl and JuggleMaster are the well-known simulators; Juggling Lab's documentation is cited here for its parameter definitions and defaults, but none of its code was read or used.

Siteswap is credited by the encyclopedia to three groups working separately: Paul Klimek in Santa Cruz in 1981, Bruce Tiemann and Bengt Magnusson at Caltech, and Michael Day, Colin Wright and Adam Chalcraft in Cambridge. A second encyclopedia article credits only Magnusson and Tiemann, in 1985. The two accounts contradict each other and this app does not pick a winner. Siteswap was not the first juggling notation either: one was proposed in 1978 and another printed in 1982.

How it decides whether a pattern can be juggled

Two ways, written separately and diffed against each other over an exhaustively enumerated space.

1. The permutation test – ten lines of modular arithmetic that has no notion of a ball.
2. A search for a periodic orbit – put objects in hands, run the pattern, and ask whether any arrangement survives a full cycle and comes back to where it started. No modulus, no digit sum.

Every sequence of period 1 to 7 over the digits 0 to 9 – 11,111,110 of them – was decided both ways. They never disagree. 86,916 of them can be juggled. A further 69,904 sequences using the letter values up to 15, 14,762 synchronous patterns and 9,723 multiplex patterns were decided the same way, plus a slower object-by-object simulation as a third opinion on the smaller spaces. For synchronous patterns there is a fourth, entirely documented, opinion: the published slide property, which rewrites a synchronous pattern as two asynchronous ones. It agrees with the simulation on all 14,762.

The object count is computed three ways too – the digit average, the number of ones in the state the pattern settles into, and the number of objects the animation actually has to invent before it stops inventing any. All three agree everywhere.

The mechanism: the hand cycle

The ballistics are ordinary. What makes juggling juggling is that two hands take turns and that a hand holds each object for a while before letting go.

• The hands alternate, one throw per beat, so the hand throwing on beat t is t mod 2.
• A hand holds an object for the dwell and throws on the beat, so it caught that object a dwell earlier: a throw of s made on beat t is caught on beat t + s − dwell and thrown again on beat t + s. Its flight is s − dwell beats.

Nothing in this app contains the rule "odd throws cross and even throws do not". It falls out: the hand that catches is (t + s) mod 2, which differs from t mod 2 exactly when s is odd. The same goes for "a synchronous pattern uses only even numbers" – an odd throw in a synchronous pattern lands on a beat when neither hand is throwing, and the general test rejects it without ever being told the rule. Both are checked rather than asserted.

A third thing falls out that is rarely said aloud: a pattern whose written period is odd only repeats physically after twice that many beats, because after one written cycle the hands have swapped. A 3 repeats every beat on paper and every two beats in the air.

The hand model satisfies Shannon's juggling theorem, (F+D)H = (V+D)N, exactly – not approximately – for every object count and dwell tested, and it reproduces Shannon's own worked example: his numbers give a dwell of 1.5 beats, and then a 3 flies for 1.5 beats, which is what this app computes.

What is faithful and what is this app's own choice

• Faithful: the notation and its validity rule; the slide property; the object-count rule; the counting theorem; the named patterns and their siteswaps; the dwell parameter, its range and its default of 1.3 beats; the typical beat rate of 3 to 5.5 per second; the standard hand style of throwing 10 cm from the midline and catching 32.5 cm from it; the flash and the qualify as goals; the ball size and mass ranges.
• This app's own: every colour; the figure and its arms; hand height; the three cameras and the rule that the camera moves back rather than the throws being shortened; the timing window a throw has to be keyed inside; the third goal, a run of ten throws per object; the shortest-flight floor of 0.25 beats; and the refusal to parse a pattern that mixes synchronous and asynchronous notation, which the notation itself permits.

Limits, gaps, and things the sources did not decide

• There is no governing body for any of this. Two organisations do publish rules – the IJA's Numbers Championships rules, which are live, and JISCON's, which are frozen and whose body is defunct – and both were read. Neither says one word about siteswap, throw heights, ball dimensions or pattern names. Anything claiming an official juggling specification for those is wrong. No body specifies a ball: the published rules require only that an object be roughly spherical with no aerodynamic lift.
• The notation cannot say whether a 2 is a hold or a tiny throw. A published FAQ says so outright, on the multiplex [23], which can be read either way. This app draws a 2 as a small self-throw. That is a drawing convention, not a consequence of the model – a genuine hold would need a dwell of a full hand cycle, and a hand that held for its whole cycle could never be empty to catch.
• The formula flight = s − 2 × dwell_ratio is folklore. It is widely repeated, and appears in no source that could be opened. The documented parameter is a dwell measured in beats, so this app uses flight = s − dwell and names the parameter the way the source does.
• Most famous tricks are not distinct siteswaps. Mills' Mess, Juggler's Tennis, the three-ball half-shower and the Statue of Liberty are all siteswap 3 – the same numbers as a plain cascade. Siteswap explicitly does not describe arm paths, and this app does not draw them, so those entries in the catalogue look identical to a cascade. They are listed anyway, labelled, because leaving them out would imply the notation distinguishes them.
• "Box" is ambiguous in published sources. At least three siteswaps are called the box: (4,2x)(2x,4), 612 (the seesaw), and two others in the list article. This app uses the first and says so. 441 is the half-box, not the box, and it is asynchronous where the box is synchronous.
• No governing body specifies a juggling ball. The encyclopedia's figures for beanbags are a range, not a standard: 2.5 to 3 inches across, that is 63.5 to 76.2 mm, weighing 90 to 130 g. This app draws a 70 mm, 110 g ball, inside that range and smaller than the reference implementation's 100 mm default, which is a visibility choice this app did not copy.
• Mixed notation is not parsed. Writing 3(4,4) is legal siteswap and this app rejects it. That is a limit of this build, not of the notation.
• The letter values above a = 10 are taken as read. Only a = 10 is spelled out in the encyclopedia; b = 11 onward is the obvious continuation and is used here without a source that states it.
• No arm paths, no body throws, no bounce, no passing, no clubs or rings. All are real juggling and none are modelled.
• The state search is capped. Patterns whose highest throw is above 14 are not offered a transition, because the state space doubles with every extra beat.
• At the documented tempo, high patterns leave the room. At 4 beats a second with the documented dwell of 1.3 beats, a 3 peaks 0.22 m above the hands, a 5 peaks 1.05 m and a 9 peaks 4.54 m. That is correct physics and the 9 is drawn at 4.54 m; the camera pulls back instead. Holding every pattern to one height instead would need about 8.7 throws a second for a 9, well outside the documented 3 to 5.5 range – which is itself the reason real jugglers throw higher rather than faster as the numbers go up.

Sources that could not be read

• Beek and Lewbel, "The Science of Juggling", Scientific American, 1995. The citation behind Shannon's theorem, the counting result and the square-root relation as the encyclopedia presents them. Its host no longer resolves and the archived copy is an image-only scan with no text layer. Every claim traced to it here is quoted at second hand.
• Polster, "The Mathematics of Juggling", Springer, 2003. Paywalled. The standard book-length treatment; the page numbers other sources attribute to it are unverified here.
• Buhler, Eisenbud, Graham and Wright, "Juggling drops and descents". The counting theorem's original paper. Its authors and title were confirmed from the bibliography of a paper that was read; its volume, year and pages are the standard citation and were not checked.
• The WJF's competition rules were not opened; only its home page, which describes the body as a global governing body. That is a self-description, and it is recorded here as unchecked rather than as "publishes nothing".

Where every number came from

qualified means documented, but of something adjacent – a hobbyist reference rather than a governing body, a reference implementation's default rather than a standard, or general physics rather than a juggling measurement. They are counted separately on purpose; folding them into DOCUMENTED would flatter the tally.

Sources

Under the bonnet

The renderer is hand-written WebGL – no three.js and no library of any kind. Every triangle of every surface is checked numerically against an outward direction rebuilt from that surface's own parameters, with a deliberately reversed copy of each surface run through the same check as a control to prove the check can fail. That check found the cylinder used for the arms and legs wound inside out before this shipped.

Every WebGL object is created inside one function, and the context-restored handler calls exactly that function again. You can prove it here:

Throw the WebGL context away

No network request of any kind is made by this page after it loads. Nothing you type leaves the browser. The only thing stored is the pattern you last looked at and your best runs, in this browser's local storage.