I've discovered (although it's probably nothing new) an easy system to translate siteswaps into shower variations. Instead of saying "high high low mid high" when doing a shower, you can find new patterns easily.
The idea is to take any siteswap, take all digits separately and "convert" them into a "shower" sequence. This would translate like this
0 -> 00
1 -> 11
2 -> 31
3 -> 51
4 -> 71
5 -> 91
6 -> b1
So you can do for example a 63641 shower, which would translate to b151b17111
It's an easy way to find new ways to make showers interesting. I'll let you think of something more fun to do than 11 sequences ;-)
Ohh, that's sweet!
Do you have an explanation/proof of why it works? Are there similar transformations that would work too?
I'd love to find solid theory for WHY it works ;-). If anybody wants to chip in, please do!
I haven't found other cases like that right now. It reminds me of a workshop by Mees Jager about sprung siteswaps where he said that 4 balls sprung is like juggling a 3 balls cascade with a ball that come and go between each throw. With that in mind, you can easily imagine nice sprung siteswaps.
Interesting, I 'discovered' early on when playing with siteswaps you can turn any 2 handed siteswap into a one handed one by doubling all the values & adding a 0 after each one:
441 → 808020
423 → 804060
531 → a06020
Which is the same thing I think. I never thought to take it a step further.
It will work as long as the 'padding digit' is always the same so that you are always spacing out the exchanges proportionally. Extrapolating it further as long as you take all your substitutions from the same column in the following table you should end up with a valid siteswap.
Digit *0 *1 *2 *3 *4 *5 *6 *7 *8 *9
0 00 00 00 00 00 00 00 00 00 00
1 20 11 02 -- -- -- -- -- -- --
2 40 31 22 13 04 -- -- -- -- --
3 60 51 42 33 24 15 06 -- -- --
4 80 71 62 53 44 35 26 17 08 --
5 a0 91 82 73 64 55 46 37 28 19
6 c0 b1 a2 93 84 75 66 57 48 39
7 e0 d1 c2 b3 a4 95 86 77 68 59
8 g0 f1 e2 d3 c4 b5 a6 97 88 79
9 i0 h1 g2 f3 e4 d5 c6 b7 a8 99
You can work out the replacement pattern bc for a using the following:
a → bc where b=2a-c & b>0
3 digit substitutions should also work.
'The Halet Transformation' has a nice ring to it :)
Yeah that makes sense! I didn't know the two to one handed theory!
The name is nice, but I wouldn't take credit for something as serendipitous as that ;-)
A similar transformation is the conversion of a two-handed siteswap its one-handed version.
All you have to do is double every number and put 0s between them.
423 in one hand is 804060.
7441 in one hand is e0808020.
This works simply because one-handed patterns can be thought of as being juggled with either (1) one hand or (2) one hand + an empty hand.
So 423 in one hand could be written as "423" under interpretation (1) or "804060" under interpretation (2).
Another example: 804060, considered as a two-handed siteswap, can be juggled in one hand as g0008000c000.
2n,0 can always be replaced by 1,(2n-1) in a siteswap.
20 can be replaced with 11; 40 can be replaced with 31; 60 can be replaced with 51 etc.
This works because, when juggling a one-handed pattern, we could, at any point, pass the ball we are about to throw to our 2nd hand, and then throw it one beat lower with our 2nd hand. This will result in the ball landing in the main hand at the same time it would have anyway.
This rule can be used to transform any one-handed pattern into a corresponding shower pattern.
This explains why the shower transformation works:
Any siteswap (e.g. 423) can be converted to a one-handed siteswap (804060), which can then be converted to a shower siteswap (171315; equivalent to 713151).
That's a good explanation starting from the two to one-handed transformation! I didn't know about that one.
It reminds me of the high diabolo siteswap notation where you can see every siteswap as a "shower version", because of the behavior of the diabolo making an oval pattern, but it can also be interpreted as a one-handed version of a two-handed siteswaps.
This idea fits within a wider method that I have often used to find new patterns. I think it is best described as: 'imagine that this small section of this complex pattern is actually this other more basic pattern' or generally just 'imagine that this pattern is actually this other one'. Another example of this method is in the following idea: 'only focus on the top section of the pattern and ignore what is happening beneath'.
For example: imagine that the 6x's in (6x,4)* are 3s in a three ball cascade. By extension you can then juggle any 3-ball siteswap as a variation of the base pattern (6x,4)*.
423 -> (8,4)(4,4)(6x,4)*
441 -> (8,4)(4,8)(2x,4)*
Similarly you can also therefore 'see' box as just a 2-ball pattern of active twos. So you can then juggle any 2 ball siteswap as a variation of (4,2x)*.
I particularly like the 2-ball snake juggled via bo:
330 -> (6x,2x)(2x,6x)(0,2x)*
For such a theoretically straightforward pattern it is surprisingly mind-bending.
This general strategy can be used for loads of patterns, such as the series 501, 801, b01 which can be re-imagined as 3,4 and 5 ball base patterns respectively, which therefore leads to patterns such as:
423 -> 801201501
534 -> b01501801
Note that in this case not all siteswaps can be juggled like this as anything with a 1 in this system becomes a -1.
Similarly 744, imagine the 7s as a 3-ball cascade:
423 -> a44444744
441 -> a44a44144
Or 534, imagine the 5s as a 3-ball cascade:
423 -> 834234534
552 -> b34234234
Or 645, imagine the 6s as active 2s:
31 -> 945345
330 -> 945045945
501 -> the borderline unjugglable f45045345
Fundamentally I think this is most useful as a way to conceptualise patterns without having to use or understand the siteswap of particular patterns. It allows you to easily generate patterns by just juggling them whereas it has taken me quite a long time to work out the siteswaps of patterns that are conceptually quite simple.
I have not really mathematically considered what it is in particular that makes certain parts of patterns translatable but it is clear that if you imagine just looking at the top portion of a pattern you can effectively ignore what goes on below and just treat the top bit as an easier base pattern. Obviously this leads to some pretty tricky patterns but conceptually they are pretty straightforward.
Subscribe to this forum via RSS
1 article per branch
1 article per post