Started juggling 2021-08

Juggler. Decent but definitely a work in progress.

I like theory.

Theory developments that I don't want to make a special point of posting:

1.

Relationships between Duration (a siteswap throw; 1,2,3...), Destination (The end position of a throw in the pattern; for 5 in 531 destination is 3 [lands on the 3rd throw]), Loops (The number of times a throw 'passes' its destination throw before landing), Period, and Order (What position a throw has in the pattern; 2 in 531 is the 2nd throw.

- Duration= y

- Destination= d

- Loops= L

- Period= P

- Order= x

- LP= y_{x}-y_{x}^{L}

- y_{x}^{L}= d_{x}^{L}-x

And with those you can make any number of interesting equations, including one where you can find the period of a pattern given a single throw's y, d, and L.

2.

One axiom that allows 333 into 441 is=

A: ss(Y_{1} y_{p})- ss((Y_{1}+1) (y_{p}+1-p)

where p is the period.

However, this is actually a composite of these axioms:

A:ss(y_{1} Y_{m} y_{p})- ss(y_{1} Y_{m} (y_{p}-p))

A:ss(y_{1} Y_{m} y_{p})- ss((y_{1} Y_{m} y_{p})+1)

Where Y_{m} is all digits between the first and the last.

This is because y_{1} with Y_{m} together is equal to Y_{1}. The +1 goes to both terms, the -p goes to just the last one.

3.

Siteswap is basically the expression of 3 variables (or 4 depending on how broadly you interpret 'siteswap').

The most obvious is the duration of the throw. Each digit tells you how long an object has before it's thrown again. However, also encoded in the system is the order of the throws. We order them from first to last, and put them in brackets if two are the same, that is, we organize the throws by their associated position in time.

The third variable is loopage, which takes us out of our happy place. The loops of a throw is the number of times it passes all the way through the pattern before arriving at its destination. In other words, how many times you can subtract the period of the pattern from a throw before it goes negative. Talking in terms of loops, each throw in 441 actually has duration 1. This is the difference between what I call y and y^{L}.

y=y^{L}+Lp is how you can express the difference between y and y^{L}.

Using these three variables, we can tell what siteswap is actually communicating to us, which is a set of 3 'coordinates' working together to create a valid pattern.

The 4th variable that might be expressed is d, the end position of a throw in the pattern. d is dependent on y^{L} and order in the pattern (which I call x), because intuitively, the position plus the duration gives you the destination (y+x=d). There is an asterisk to this, because y+x can be greater than the period of the pattern, and d is never higher than the period of the pattern. So the way I describe it is (y+x)^0, indicating that whatever number y+x is, subtract the period until the loops for that number would equal 0.

There are two major relationships between these 4 variables:

Lp=y+y^{L}

(because

y^{L}+Lp=y)

0=d^{L}-y^{L}-x

(Because d^{L}=(y^{L}+x)^0 and Lp=y+y^{L})

(This can give substitutions for any of the three variables based on the other two.

(Also, 0=y-d-x for similar reasons)

Because of these relationships, we can tell that any juggling notation that conveys the same information as siteswap is allowed to omit any of the 4 variables (any 1 variable can be determined by looking at the other 3). So we can transcribe what exactly a notation tells us. For example I would call siteswap a (yLx) language. Parenthesis are used to convey that each variable is encoded in some way. y and L are combined (via y+Lp), and their organization chronologically encodes x. Notating sitewap with both loop and duration (ie. 441=1^{1}1^{1}1^{0} would be a yL(x) language. Simply listing each variable would be a ydxL language.

4.

It is possible to encode all three essential variables into a single digit, meaning that it is possible to notate with no regard for order.

Siteswap takes each y of a sequence and makes it (y+Lp). Turns out you can take a similar step with x. The first conversion works (ie. you can retrieve both of the original components) because y is always less than p. Never greater than or equal, because then you could subtract the period. Well, x is always less than **or equal to** the period. Because x is allowed one number higher than y, we can turn (y+Lp) into (y+Lp)+x(p+1). So then, 441 can be called 8gc. Or 8cg. Or cg8. Or literally any other combination of those three characters.

Which isn't helpful. But it is interesting, so there you have it.

(side note: for numbers larger than 36 [which can occur fairly often using this method], I use capitals, using only lowercase letters before that point. So 88441 = CHjo6. Or jH6Co. You get the picture.)

Forum post count: **6**