Lesson 14 for MM STD

We have seen in MM_STD_08 how to compute the time-reversal of an ordinary pattern. The question now is, how do we compute the time-reversal of a Site Swap with hand movements?

This is a good question!

We'll start with a comparatively simple answer, and then go from there. What follows here first is a purely mechanical procedure for computing the time-reversal of a pattern. We will use Rubenstein's Revenge as our example.

First, write it all in reverse order ...

Next, change all "i"s to "o"s and vice versa and change all "A"s to "B"s and vice versa

Now move all "A"s, "B"s and "U"s one place earlier, moving the first one, which would sort of fall off the front, to the last place ...

So far this is exactly the same as our previous reversing procedure, except that it's being done in the new notation rather than on the diagram. The last few steps take into account the Site Swap we have.

Move each number two places right, moving the ones that fall off the end back on at the front ...

And for now the last step. Take each number and move it backwards. The amount by which to move it is given by the number itself. For example, move a 2 backwards by two places, and move a 3 backwards three places. When you fall off the front, come back on at the end. This will mean that the 5 will stay where it is.

That's it !

You may wonder if and why this last bit always works. After all, since the numbers move by different amounts, why are we never unlucky and end up with two numbers being moved to the same place? Well, it turns out that if you do end up with that sort of clash, then the original sequence of numbers can't have been a valid Site Swap. This is precisely the requirement for a sequence to be a valid Site Swap, so if you start with a valid Site Swap, it never goes wrong.

Well, of course, we've given little or no justification for most of this, and you might wonder where it all came from. As we said above, the origins of the first few steps can be traced back to the time-reversal on the diagram. The last two steps are derived from the time-reversal of an ordinary Site Swap. To see the comparison, here is that process applied to the Site Swap 1 2 3 4 5 ...

First, write it backwards ...

Now, from each place count backwards by the amount given by the Site Swap value. For example, from the 2, count backwards by two.

That's it. You can see the similarity in the processes. The main difference is that in the full process above we shift the numbers by two places. A shift like that is irrelevant in ordinary Site Swaps, but here it serves to make sure that the Site Swap values are lined up correctly with the arm movements.

We can see the whole process in action on the full diagram.

 
  +----+ ######     +----+
  | Lr | # Lr # 5+> | Ll |      Here we've drawn the diagram
  +----+ ######     +----+      for Rubenstein's_Revenge,
   ^   3   ^            2       although it has been a some-
   o   +   o            +       what compressed.  We've also
   2   v   3            v       doubled up on those states
+----+ +----+   +----+ +----+   that occur twice in the
| Ul | | Ul |   | Ur | | Ur |   pattern, for clarity.
+----+ +----+   +----+ +----+
    ^            3   ^   2      When we work out the time-
    +            o   +   o      reverse we exchange every
    2            v   3   v      *r* for *l* and vice versa,
   +----+     ###### +----+     we reverse the arrows, and
   | Rr | <+5 # Rl # | Rl |     we exchange *o* and *+*.
   +----+     ###### +----+

                                So here's the time-reversal,
  +----+ +----+     +----+      but where should we put the
  | Ll | | Ll | <o- | Lr |      numbers?  To see this, let's
  +----+ +----+     +----+      follow the *5* from state
  |    ^    |           ^       *Lr* marked in the diagram
  +    o    +           o       above.  That ball will next
  v    |    v           |       be thrown five beats later
+----+ +----+   ###### +----+   (because that's what the *5*
| Ur | | Ur |   # Ul # | Ul |   means in SiteSwap).  That
+----+ +----+   ###### +----+   will then be in state *Rl*
    |           ^    |    ^     on the diagram above.
    o           +    o    +
    v           |    v    |     Because the ball will be
   +----+     +----+ +----+     thrown there, it must have
   | Rl | -o> | Rr | | Rr |     been that ball that had been
   +----+     +----+ +----+     caught on the previous left
                                hand exchange, shown at left.

So, the 5 thrown in the normal-time pattern from the state "Lr" becomes a 5 thrown from the marked state above in the time-reversal.

So that's how we compute the time-reversal of a Site Swap with hand movements, and it brings us close to the end of the tutorial series. In MM STD 15 we'll review some of what we've seen, and take a second look at some of the details and terminology.

Quotation from Tim Berners-Lee