One of the most popular aspects of siteswap is the ability to generate new patterns you may not have previously thought of. There are a number of mathematical operations you can perform on a valid siteswap to create a new valid siteswap. These operations are commonly called 'axioms'.

Ben Beever lists 4 axioms which may be used to generate all valid Vanilla siteswap patterns in his book Ben Beever's Guide to Juggling Patterns (see page 4, section 8). Ben's book is excellent although geared towards the mathematically minded so I'm going to try & explain things a little more simply here.

Throughout this page we will only be dealing with Vanilla siteswaps.

## Axiom notation

Firstly a bit about the notation I'm using. To the uninitiated axioms just look like a load of nonsense:

A4: SS( A b C ) - SS( A b+p C )

Right at the start the 'A4:' is the name of the axiom & is short for 'axiom number 4'.

The SS(...) parts state that anything within the brackets is a valid siteswap.

The dash ('-') is shorthand for saying 'if the first is true then the following is also true', that is if the initial siteswap is valid & can be broken down as described by the contents of the first bracket then the new siteswap created by using the breakdown in the second bracket is also a valid pattern.

The contents of the brackets are where things get interesting. The letters & numbers inside the brackets are patterns for describing a siteswap, not the actual siteswap itself. On this page I've used capital letters to denote a sequence of integers (any whole number including zero, you can use negative numbers which will create valid patterns, but not ones that can be physically juggled), the sequence can be of any length & could even be empty. Lower case letters denote a single integer.

There are some special cases though, 'p' for example may stand for the period of the siteswap. The period of a siteswap is the number of beats, & for Vanilla siteswaps is simply the number of digits in the string.

After each axiom on this page I will spell out what each part of the pattern means again.

To be able to use axioms you need to be able to break down a siteswap into component parts as described in the first pair of brackets. You then reuse these components as described by the pattern contained in the second pair of brackets to create a new pattern. So let's start by looking at all the different ways a simple siteswap 12345 can be broken down using the pattern SS( A b C ):

A | b | C |
---|---|---|

1234 | 5 | |

123 | 4 | 5 |

12 | 3 | 45 |

1 | 2 | 345 |

1 | 2345 |

Note that the first & last possible breakdowns are examples of one of the components being an empty sequence.

## A1: SS( aaa...a )

a is a single integer

The first axiom simply says that any string made up of all the same digit (11111, 2222222, 3333333 etc.) is a valid siteswap. If every throw in the pattern is the same then we have a valid pattern.

There is no second pattern to transform this siteswap into another. This axiom exists solely to give us a valid starting point.

## A2: SS( A b c ) - SS( A c+1 b-1 )

A is a string of integers of any length

b is a single integer

c is a single integer

The second axiom shows a basic 'site swap' after which the notation is named. The last 2 digits in the string may be swapped so long as you then increase the value of the first digit by 1 & reduce the second value by 1.

For example let's start with a simple valid siteswap:

12345

We are going to take the last 2 digits...

12345

...& swap them over...

12354

...add 1 to the first digit...

12364

...then subtract 1 from the second.

12363

Remember when using A2 that if b is 0 (zero) then you will end up with a negative throw, which although valid in terms of siteswap will be impossible to juggle.

More efficient versions of A2 may be used which are at the end of this page under Non-Beeverish axioms.

## A3: SS( A b ) - SS( b A )

A is a string of integers of any length

b is a single integer

This axiom states that the digits of any valid siteswap may be **cycled** & you still end up with a valid siteswap. The exact same pattern in fact, you just start the pattern from a different point.

For example starting with the base 12345 again...

If A=1234 b=5 then:

51234

A becomes 5123 b becomes 4:

45123

A becomes 4512 b becomes 3:

34512

A becomes 3451 b becomes 2:

23451

A becomes 2345 b becomes 1, which takes us back to the beginning:

12345

## A4: SS( A b C ) - SS( A b+p C )

A is a string of integers of any length

b is a single integer

p is the period of the pattern

C is a string of integers of any length

The period of a siteswap is the number of beats, & for Vanilla siteswaps this is equal to the number of digits in the string.

This axiom states that for any given siteswap you may add the period to any digit.

For our example pattern of 12345 the period is 5 (there are 5 beats in the pattern). We may add this number to any digit of the original siteswap:

62345

17345

12845

12395

1234A (A = 10)

Similarly you may also subtract the period from any digit that is greater than the period. For example the pattern 642 has a period of 3 & could be modified to:

342

612

64-1 (although good luck with juggling that)

## Non-Beeverish axioms

Here follows a few modifications to the axioms covered by Ben's book & a couple of new ones. If you know of any more please let me know.

## A2.1: SS( A b c D ) - SS( A c+1 b-1 D )

A slightly more efficient version of A2 includes an extra D on the end to show that the swap can occur at any point in a siteswap, rather than just the last 2 digits. This means that you don't have to use A3 quite so much.

## A2.2: SS( A b C d E ) - SS( A d+n C b-n E )

n is the period of C +1

An even more efficient axiom which states that **ANY** 2 digits may be swapped, not just those that are directly next to each other.

## A3.1: SS( A B ) - SS( B A )

To save using A3 multiple times you could use A3.1, which is effectively the same. Instead of carrying a single digit from the end to the beginning, you can take any set of numbers & reapply them to the start.

## A5: SS( abc...z ) - SS( a+1 b+1 c+1...z+1 )

a-z are all single integers

This axiom states that you may increase the value of **ALL** the digits in a valid siteswap to make a new valid siteswap.

So adding 1 to all the individual digits in 12345 leaves us with 23456.

As with A4 you could also subtract 1 from each digit, although difficulties may arise if the pattern contains zeros.

## SS( A ) - SS( A n )

A is a string of integers of any length

n is the number of balls in the pattern

This last one is **NOT an axiom** (hence no A6). There are many cases where it doesn't work! I've decided to include it because in the cases where it does work it is very useful because it can create a symmetrical pattern from an asymmetrical one.

For example the 4 ball pattern 53, becomes the considerably more elegant 534.

This pseudo-axiom always works when A ends on ground state, & in lots of other cases too.