# dNote, a siteswap extension

## Table of Contents

# Introduction⌗

This is my first draft of an alternative system for siteswaps, with the working title dNote. In dNote you denote every relevant hand on every single beat.

Some practical issues with siteswaps:

- It is hard to combine synchronous with asynchronous siteswaps.
- It is difficult to add in a third hand/foot/elbow etc. that interacts with an object
- Siteswap for multiple people becomes one unreadable global siteswap or a few disconnected local siteswaps.

I intend to solve for all of these problems by combining siteswaps with beatmap or multi hand notation (MHN). But both beatmap and MHN have issues of their own.

Beatmap cons:

- It can be confusing for people who are used to siteswaps since typically a throw is written down one number lower than with siteswaps
- One is encouraged to differentiate between a cascade as
`(2x,1)*`

and`(3x,0)*`

but since the pattern does not describe catches and most juggling happens in exchanging throws (the catch in a hand and thus the hold takes place the same beat as the throw from that same hand) this differentiating is often irrelevant. - A pattern with more than 1 hand or manipulator comes with a lot of redundant information.

MHN cons:

- A lot of redundant information.
- Designed to communicate with juggling software, not necessarily with jugglers.

I will show how dNote solves all of these issues from all 3 systems, but at the same time taking inspiration from them.

As a bonus, I’d like to include starts and stops into juggling. They are a very common part of juggling which are required for every single pattern or sequence, but they are very hard to describe except using the Harmonic Throws grid.

# Every hand on every beat⌗

I would like to reimagine siteswap by displaying the siteswap of every hand on every beat.

For now, I’m putting time on the x axis. The siteswap `441`

could be written as:

```
L R
4 0
0 4
1 0
0 4
4 0
0 1
```

This still works with the normal ladder diagram arcs, which I often add on paper, but here is a poor ascii attempt:

```
L R
| 4 0 /
\ / /
/ 0 4
/ \ \
| 1 0 \
\ \ \
\ 0 4 |
\ \ /
4 0 \
/ / \
/ 0 1 |
/ / /
```

Let’s immediately simplify this by taking away the repetition, from the

```
4 0
0 4
1 0
```

Before we compress this into less redundant syntax, we should have a look at synchronous siteswap. Let’s do the ‘box’, `(4,2x)*`

. To better understand what happens here I wrote it on both sides. The 2x notation comes from synch siteswap and means ‘to the opposite hand than normal’, a 2 is an even throw so should return to the hand it was thrown by, but now it crosses. In dNote we will stick to that convention.

```
4 2x 4 2x |
0 0 / / /
2x 4 / 0 / 0 /
0 0 / / /
| 2x 4
or -> \ \ \
\ 0 \ 0 \
\ \ \
```

It now becomes obvious that a 4 still takes 4 beats to land. This may seem insignificant, but in traditional siteswap we are usually not thought about this beat and instead use a (left hand) `4`

in this pattern because the right hand takes up a beat too, so that each “beat” is a hand just like in alternating siteswap.

Beatmap and MHN have already done away with this system of forcing alternating hands and both put synch and asynch siteswaps in the same grid. Beatmap is more consistent than dNote with the use of the `x`

notation by saying every same hand throw is without x and every crossing throw is with `x`

, but in order to be more compatible with siteswap and less redundant (you’ll have a lot of x’s in standard patterns with beatmap) we will stick to `x`

meaning crossed for even throws and straight for odd throws.

This makes it much easier to work out transitions between synch and asynch siteswaps, for example consider the pattern `34x1x(4x,3)`

. Patterns with odd numbered x throws are very rare to describe in juggling, I had never used them until now because it is hard to understand what is going on with the common methods we use to think about synch siteswaps. However, if I write down every beat it becomes less hard to understand:

```
0 3
4x 0
0 1x
4x 3
0 0
```

Despite this now being a 5 beat pattern, it is still one sided. From the dNote it becomes easy to see which ball goes to which hand, and that it doesn’t loop.

All that I want to describe with dNote so far can be described with siteswap, even patterns that make use of the `0 0`

that comes after a synch throw. There is a very obscure notation using `!`

to denote a ‘short’ synch throw, I discovered it by accident when juggle lab suggested a transition for me which used it. For example you can alternate between synch and asynch with `4x1x(3,1x)!`

```
0 4x
1x 0
3 1x
```

## No Hurry Rule⌗

With dNote and short synch notation you have to watch out to not give a hand too much work, if it has to do an action twice in a row it could be hard to do in a normal rhythm. In passing this would be considered a “hurry”. Only a `1x`

can be followed by an action in that same hand in normal tempo patterns.

By default we’ll assume that no hurrys are intended, this will be important later.

# Shorthand⌗

Writing columns for each hand is useful to see what happens in the pattern, but in order to communicate efficiently we’re going to remove all redundant information.

For each row, only the columns that are not 0 need to be written down. Unless there are no numbers other than 0 in the row then a 0 needs to be written.

So the ss: `4414440`

is also written as dNote: `4414440`

```
0 4 > 4
4 0 > 4
0 1 > 1
4 0 > 4
0 4 > 4
4 0 > 4
0 0 > 0
```

We will know that `4414440`

needs to be executed with alternating hands because of the No Hurry Rule.

For synch siteswaps we will stick to the convention of normal siteswap syntax, which is to enclose all throws with brackets () and separate them with a comma. The comma is redundant but it can help readability. We will also take the `*`

notation from synch siteswaps to say “repeat mirrored”.

The “box”, ss: `(4,2x)*`

now becomes dNote: `(4,2x)0*`

```
4 2x > (4,2x)
0 0 > 0
```

Arguably the `*`

could even be omitted as there is always only one way the pattern could be valid. Then the box becomes `(4,2x)`

. I think it is acceptable for extra clarity, but a siteswap simulator should accept the version without the `*`

(and maybe make a mention that this is a mirroring pattern). When talking about patterns we don’t usually mention the `*`

anyway, we usually say “four two x”.

Multiplexes work the same as in siteswap:

```
33 0
0 3
3 0
```

This becomes [33]33 in shorthand.

# Adding manipulators⌗

Synch to asynch is cool, but the true power of dNote is being able to add an extra hand, foot, elbow, head or anything else as an interaction site.

In traditional siteswap, if you want to describe an extra hand you will have to consider if you want to turn your pattern into 3 handed siteswap by cycling through the hands as `RLE`

with `E`

being the Extra hand. This works, but it means all your throw heights are different now. A `2`

is no longer a hold, a `4`

from the right hand is a throw to self but a `4`

from the left hand becomes a pass.

Because this is confusing, most passers work with “local siteswap”, a standard 2 handed siteswap for each juggler with extra notation when a pass is made. However, that means that you will have to write down multiple patterns. Because this can get tedious, most passers who juggle complex siteswaps together stick to symmetrical siteswaps so that they all use the same, perhaps shifted by a few beats. This is commonly known as “prechac”, after Christophe Prechac who came up with a method of transforming siteswaps into symmetrical passing patterns.

However, a local siteswap becomes unpractical for solo jugglers who want to add their foot to a pattern.

Let’s have a look at a simple foot catch pattern in dNote:

```
L R F
0 0 3R
0 3 0
3F 0 0
0 3x 0
3x 0 0
```

dNote: `3R33F3x3x`

Now we have to specify which object goes where. The rule here is:
`x`

means crossed to the opposite when even numbered or straight when odd numbered, but can only be used if there is a right & left pair in the pattern, such as a pair of hands and pair of feet.

No `x`

means regular siteswap crossing, but if there is no pair (as in this example pattern, there is only 1 foot noted) a throw always returns to the place it was released from.

You now have to specify where a prop goes to if you want to switch from one manipulator or pair to another. In this example I set the key (a concept from beatmap) as `L R F`

meaning Left, Right and Foot, but everyone can make up their own keys with their own terms however it suits them. For body contact positions I would recommend testing out these spots and abbreviations.

So a `3R`

throw goes to the right hand, which only needs to be specified if the throw is not made from one of the hands.

In order to avoid naming “left” and “right in a pattern, so that a pattern can be easily mirrored, we introduce the `-`

character. This means something like “go back to where you came from”. We can append it with `x`

to mean the “the pair you came from, but opposite side.

So now the pattern becomes `3-x33F3x3x`

In this particular pattern the usage of `-`

is slightly confusing as only later in the pattern it becomes clear where the prop originated from. However it can always be deduced except in a pattern start. More on that later.

The `3x`

means a long hold, because of the No Hurry Rule we know that there can never be a throw in between the pattern. In the example pattern there is a break in which the hands are holding on to the ball some time.

Another foot juggling trick is continuous exchanges with 4 balls: Right throws to left, left throws to the foot, foot throws to the right, and there is always at least one ball in the air. This pattern is dNote: `(3,1x)(3F,1x)(1x,3-x)`

```
L R F
3 1x 0
0 3F 1
1x 0 3-x
```

This pattern could in theory be simplified into `4x4F4-x`

, however I much prefer to stick to the unwritten rules of siteswap that we’ve gotten used to: A throw is caught about n-2 beats later. So a `3`

arrives one beat later, a `4`

2 beats, and a `1`

has “already arrived” and can be used immediately. When you juggle this pattern you will notice that in both the hands and the feet there is some time where the object is held, this is exactly the `1x`

. For similar reasons siteswap distinguishes between `3`

and `522`

.

There is another issue with `(3,1x)(3F,1x)(1x,3-x)`

, it can be unclear which action refers to which hand. In this case if we set the key to L R F there is only one way possible, as `1x`

does not make any sense for the foot. However, for other patterns it can be required to denote all the hands, at least at the start of the pattern. It then becomes `(3,1x,0)(3F,1x)(1x,3-x)`

, and now with the No Hurry Rule all the other parts can be easily worked out. An elegant rule for this still needs to be worked out, this is on the *TODO*.

When there are multiple jugglers you could prefix hands with A, B, C, etc.

# Key⌗

At the start of a pattern you can define which manipulators there are in which order, like hands, feet, multiple jugglers, etc. If this is omitted one can generally assume the pattern is intended for key `Left hand - Right hand`

. The key is described in curly brackets: `{L,R,F}`

for Left, Right, Foot.

# Starts & Stops⌗

Something else I’d like to be able to describe in dNote are starts and stops. Siteswaps always assume you’re in the middle of a pattern, but in the real world juggling always starts and ends. This observation was probably inspired by Harmonic Throws, which unlike siteswaps always assumes you’re not juggling.

More work needs to be done with this, but the current shorthand I have in mind is this:

`{L1,!R2}333`

This means: One ball in the left hand, 2 balls in the right hand, start juggling the pattern 3 beginning with the right hand. A simulator should assume a collect if a start is written, so after the 3 throws the pattern stops, the correct amount of balls are put in the correct hand, and the pattern restarts.

The `!`

means ‘this hand starts’. I suggest these conventions: If the ‘!’ is omitted, for example in `{L2,R2}4444`

, the right hand starts by default as this is the current setup in Juggling Lab, and when communicating your patterns to others you can easily describe what you want them to do or it might not matter. However, if the pattern is invalid, a simulator could perhaps automatically mirror if that solves it. So `{L2,R1}333`

can be understood as having to start with the left.

Another convention I suggest is that if the `L`

or `R`

is omitted, the first field in the `{}`

brackets can be assumed to mean left and the second to mean right. Or actually, it can be assumed to mean that the second field is the one to throw first, it doesn’t really matter if that is left, right or a foot. Speaking of feet, one is free to make up key for the pattern of course, if you want `{F1, H2}`

this might mean 1 ball on the foot and 2 on the head.

To stop a pattern, all one needs to do is write `$`

which means ‘collect’. The juggler stops tossing at this point and collects the balls which are still in the air. No need for complicated multiplex notation. So `5151$`

means to go from a “shower” pattern to collect all the balls. A juggling simulator could then offer to do a simple entry throw to get back into the pattern, in this case it could automatically do the start `{!L2,R1}4`

to get into the correct juggling state for a shower.

# Mathematical properties⌗

In many ways dNote behaves similar to siteswap, for example the amount of objects is still the all the numbers added divided by the number of beats.

So for example the dNote pattern `4x1x(3,1)`

is `(4+1+3+1) / 3`

= 3 objects.

Also of course every valid vanilla siteswap or multiplex is valid dNote, and to convert from synch siteswap to dNote you only need to add a `0`

after every bracket. For example `(2x,4)*`

becomes `(2x,4)0*`

. This pattern is now 2 beats, so `(2+4) / 2`

is indeed 3 balls.

The one thing that is different is that it is no longer possible to tell from the amount of beats if the siteswap is symmetric or not. A 4 beat siteswap could repeat on both sides, for example the 4 beat pattern `(1x,4x)300`

is symmetric and alternates hands. If one chooses to add the optional `*`

to the pattern it becomes clear again that odd beat patterns are asymmetric, even patterns are symmetric, but with a `*`

it will be the opposite.

# Did we solve the problems?⌗

Let’s go over the issues one by one that were listed in the introduction and see if they are solved now.

*Hard to combine siteswaps with synch with asynch siteswaps*

The `x`

notation still exists and can be confusing, but the `!`

notation is no longer needed. By putting a `0`

between synch throws it is easier to understand the missing beat and thus direct throws to it.

*Hard to add a extra hand/foot/person in siteswap*

You add a column, which only appears when it is being interacted with. One has to write down to which column a throw like `3F`

goes but only if it is not just the hands. Much simpler than in global siteswap or 2 separate siteswaps. Also the siteswap can still be separated if desired which can be useful for multiple jugglers, just write down shorthand for each column separately.

*Beatmap is confusing if you’re used to siteswap*

Siteswap conventions are retained in dNote, even if that means there are weird rules such as that odd numbers cross and even numbers go straight, except with an `x`

. A valid siteswap pattern is also a valid dNote pattern.

*Beatmap encourages to write the cascade as (2x, 1)* or (3x,0)* when there is no clear difference*

The No Hurry Rule makes

`(2x,1)*`

invalid in dNote. Also, because of this rule there is no need for the `*`

as it can be deduced, so the pattern becomes simple `3 0`

or `3`

in shorthand. Of course it is still possible to write `522`

or `(6x,0)`

in dNote, which I think is meaningful.*Beatmap and MHN come with a lot of redundant information*

In dNote hands that are not doing anything are omitted.

*MHN is designed to communicate with software rather than jugglers*

There is a long form and short form of dNote, for many patterns short form is probably easy to read especially because it is similar to siteswaps, but you can always translate it to the long form and draw columns for each manipulator.

# Issues⌗

In Juggling Lab, siteswaps start on the right hand by default and synch siteswaps are written (L,R). Therefor if you are graphing out siteswaps in the way I proposed you have to make sure to start on the right side of the graph which is a bit counter intuitive when writing left to right. So a graph starts:

```
L R
0 3
3 0
```

Of course this is specific to Juggling Lab, but anyone who will want to mix siteswaps with synch stuff will come across the same issue that a choice needs to be made. The easiest solution is to remember to always start left?