A siteswap question

Evening all. In playing with coding a n iOS siteswap animator and I'm wondering what simple manipulations can be made to a vanilla siteswap to turn it into another valid siteswap. Didn't find my answer quickly although I'm sure this had been discussed a lot so thought I'd give up and ask here! I can think of these:

- add period to any number (423 becomes 534)

- subtract period from any number >= period (534 becomes 504)

- add n objects by adding n to all digits (423 becomes 645 etc)

- subtract n objects by taking n off all digits (so all digits need to start high enough)

I'm not sure what will always work for changing period though. If the SS is written biggest digit first will it always work if you add the number of objects on the end? So 53 becomes 534 etc? What about the reverse of that? (When the last digit of a sorted SS is the number of items). I haven't thought of a counter example...

Any others?

Adding the number of objects to the end only works for ground state siteswaps. (Or if you are lucky.) If you have 45123 you can add any number of 3s after, but if you write it as 51234 you can't add 3, 512343 isn't a valid siteswap. 55050 is not ground state and you can't just add a 3 anywhere.

The only other manipulation I can think of is the actual "siteswapping" manipulation; switching the landing time for two of the throws. Easier thought of as switching places of two numbers, increase the one moving to the left with the number of steps it moves, decrease the one moving to the right.

For example: If you have 555555 you can swap the 3s in the middle and get 556455, or the two closer to the ends to get 585525, or the ones on the ends to get a55550, or do all of them and get a86420. Or swap the first and third to get 753555 or...

Works for other siteswaps as well. 9647772 can be changed to 9649752 by swapping the first and last of the 7s, or 9557772 by swapping 6 and 4, or something else.

We're talking about siteswap, but still the site swapping part of your answer hadn't occurred to me even though I've observed the numerical patterns behind it before. Definitely something I want to implement! Thanks again.

So, I don't know anything that will always work for changing period, either, except if you know that it is ground state.

Links:

* 'Creating new siteswaps' heading here has a lot, not all of which will work for you (useful ones are time reverse, dual, maybe convert to shower/one handed form): https://juggle.fandom.com/wiki/Siteswap?mobile-app=false

* I think all these have already been covered, but it's got nice descriptions https://www.twjc.co.uk/siteswapaxioms.html

* 'Siteswap pinch ups': https://youtu.be/Df9CEzL38qs

RE changing length, the ones I can think of (beyond adding the number of balls if ground state) are:

* Add transitions to/from ground state (only for excited state patterns)

* Boppo's siteswap pinch ups (I never spent the time to convince myself these always worked, but I trust him on them)

* Doubling there pattern (441 => 441441), combined with other ones it could be useful

* [Probably too rare] If all throws modulo the period and period+1 are the same, can add that value + K*(period+1), e.g. 17 => 174 (1 and 7 are both 1 when taken mod 2 & 3)

* [Probably too rare] If all throws modulo the period and period+1 are the same, can add that value + K*(period+1), e.g. 17 => 174 (1 and 7 are both 1 when taken mod 2 & 3)

I'd not heard of this one before so I did a little spreadsheeting to see how it works & see if it was any use.

Firstly I got a little confused by K not being explicitly stated as throw weight % period, & for some reason I thought "that value" in the "that value + K*(period+1)" bit was part of the sentence & not part of the formula. "that value" is K so really the digit that you can add to the pattern is K * (initial period + 2) just in case anyone else made the same mistake.

Each cell in the following table shows the K values (throw weight % period) for an initial period p & final p+1 pattern.

Initial period > Final period | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|

Throw | 1 > 2 | 2 > 3 | 3 > 4 | 4 > 5 | 5 > 6 | 6 > 7 | 7 > 8 | 8 > 9 | ||||||||

0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |

1 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |

2 | 0 | 0 | 0 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 |

3 | 0 | 1 | 1 | 0 | 0 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 | 3 |

4 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 4 | 4 | 4 | 4 | 4 | 4 | 4 | 4 | 4 |

5 | 0 | 1 | 1 | 2 | 2 | 1 | 1 | 0 | 0 | 5 | 5 | 5 | 5 | 5 | 5 | 5 |

6 | 0 | 0 | 0 | 0 | 0 | 2 | 2 | 1 | 1 | 0 | 0 | 6 | 6 | 6 | 6 | 6 |

7 | 0 | 1 | 1 | 1 | 1 | 3 | 3 | 2 | 2 | 1 | 1 | 0 | 0 | 7 | 7 | 7 |

8 | 0 | 0 | 0 | 2 | 2 | 0 | 0 | 3 | 3 | 2 | 2 | 1 | 1 | 0 | 0 | 8 |

9 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 4 | 4 | 3 | 3 | 2 | 2 | 1 | 1 | 0 |

The cells highlighted in green show all the instances where the K values match in both the initial & final pattern. By looking down a column & picking out all green cells with a matching K value we can produce a list of candidate throw weights that we can use to create a siteswap that will be eligible for this transformation.

From the above table we can work out the following.

For converting a period 1 to a period 2 pattern.

When K = 0 we can see there are 5 candidate throws: 0, 2, 4, 6, 8.

Digit to add = K * (p+2) = 0 * (1+2) = 0

0 > 00

2 > 20

4 > 40

6 > 60

8 > 80

Which makes sense, we know that for every fountain we can drop one hand & juggle half the props in the other hand.

For converting a period 2 to a period 3 pattern there are 2 unique candidate lists.

When K = 0 there are 2 candidate throws: 0, 6.

Digit to add = K * (p+2) = 0 * (2+2) = 0

00 > 000

06 > 060

60 > 600

66 > 660

When K = 1 there are 2 candidate throws: 1, 7.

Digit to add = K * (p+2) = 1 * (2+2) = 4

11 > 114

17 > 174

71 > 714

77 > 774

(You can add the extra throw anywhere in the sequence, not just the end)

For all higher period patterns there are no instances where there is more than one candidate throw. So the only thing this method tells us is that we can modify an n prop base pattern into an n+1 prop pattern that takes the form of an n prop base pattern underneath a high throw.

While extending the range to include higher throw weights will increase the number of candidate throws the values quickly become so large as to be impractical. There will be p-1 groups of candidates & the difference between each candidate will be p^{2}+p.

So I think the reason this is rare is because it is computationally intensive & doesn't tell us much!

I'm glad I took the time to work all that out! :P

There will be p-1 groups of candidates

No there won't. There will be p groups of candidates.

"The cells highlighted in green" would not be the phrase I'd've used there. :-)

Eh?

Oh.

It would appear green was a poor choice!

It's clearer if you mark as read before reading!

Thanks for looking into that! I'd been meaning to look into it but hadn't gotten around to it (I mostly came up with it as a way to explain the "why can we add 'n' for the end of so many 'n' ball tricks, even if not ground state?").Firstly I got a little confused by K not being explicitly stated as throw weight % period, & for some reason I thought "that value" in the "that value + K*(period+1)" bit was part of the sentence & not part of the formula. "that value" is K so really the digit that you can add to the pattern is K * (initial period + 2) just in case anyone else made the same mistake.

Sorry yeah my explanation wasn't very clear, however that's still not quite what I meant, the 'that value' was referring to the value of any ss throw in it when taken mod the period or period+1. So in the case of 60, both are 0 when taken mod 2 & 3, so the new number is K*3 for any K, this means 603, 063, 600 and 606 can also be found as well what you had. Similarly for 71 you can get 711, 714, 717 and 174.

Essentially this is looking at siteswaps for which the 'base siteswap' (siteswap mod period) is constant, and adding an extra instance of said constant is also valid (hence must also be constant mod period+1). Then you can just add/subtract the (new) period as required.(You can add the extra throw anywhere in the sequence, not just the end)

Good point!

Agreed about it not working so well when it gets to higher periods, I wonder if there's a generalisation of it which is more common? I went with the simplest version to begin with, which is a set of sufficient conditions to allow the adding of a new value to the base siteswap, however there might be better options that don't need it equal for both p and p+1. Thinking through it in a bit more detail, I think it's enough for them to be constant mod p+1.

Example for new rule:

Original

b 1 6 6

Base

1 1 1 1

Extended base

1 1 1 1 1

K = 0

b 1 6 6 1

K = 1

b 1 6 6 6

K = 2

b 1 6 6 b

I'd agree with this last statement.

Any siteswap where all throws are constant mod p is valid.

So the constant mod p and mod p+1 is only relevant if you wish to construct something (which is valid because everything is constant mod p+1) from an existing pattern (where everything is constant mod p).

But that 2nd part is not necessary.

PS - sorry if I'm saying something that was already said, I was skimming a bit.

- add period to any number (423 becomes 534)

Or 423 becomes 723, 453, 426!

To slightly expand on Maria's point for adding the number of objects: you can only add this number immediately after a throw that puts the pattern into ground state.

eg. for 123456 (3 objects) the states are:

Initial state 1,0,1,0,1

1 > 1,1,0,1

2 > 1,1,1 (Ground)

3 > 1,1,1 (Ground)

4 > 1,1,0,1

5 > 1,0,1,0,1

So you can add a 3 after the 2 or the 3 which both produce 123345.

Which now that I think about it means you can add or insert any number (or sequence of numbers) that puts the pattern into the same state. eg. 12345 finishes on 1,0,1,0,1 to keep the pattern in the same state you can throw 15 or 60 (1234515 or 1234560).

(I am so proud of https://twjc.co.uk/calculator.html, it's bloody useful!)

Thanks for all those answers. They've given a bit of clarity in the patchier areas of my understanding, particularly relating to ground state. That tends to be enough to switch my brain into 'la la, not listening' mode but I'll have a deeper read about it.

And yes, that was a single example for 423!

I've got JMLib (JuggleMaster's engine) working in the app so now I'm thinking about a UI that's more fun/interesting than a text box or a list.

You can also take away an *orbit*.

( for *333* this simply becomes e.g. *330*; for *531*, it can become *501*, but also .. )*531531* can become*031530*.

A special case that can be inferred from other observations:

Siteswaps containing only 2 different numbers are valid if and (almost) only if the difference = period [1]. In that case, any ordering is valid.

'7'+'3': period 4 => 7333, 7773, 7733, 7373 (aka 73)

'6'+'3': period 3 => 663, 633

'5'+'3': period 2 => 53

'4'+'3': period 1, but period 1 can't contain '4' and '3' -> contradiction -> no valid

I say almost because of dealing with prime/non-prime siteswaps and the need to generalize.

71717171 & 73 are valid, but not period 6 & 4.

I guess you could say "/if/ the pattern can be written as being period P=k(A-B)".

[1] I wanted to say that this holds also for "a multiple of the period" as well, but I'm not certain.

Subscribe to this forum via RSS

1 article per branch

1 article per post