[r-t] All runs in a quarter, proper version

Sun Feb 1 03:18:16 UTC 2015

I'm pretty excited about how well this 1536 turned out!  I for one would 
be keen to ring it.  Here is the whole thing written out, with the runs 
highlighted:

http://www.math.ubc.ca/~holroyd/runs.pdf

I've put together a description of the process that went in to composing 
it.  In particular I hope this will answer Philip's questions, and perhaps 
encourage others to explore this interesting new paradigm.

I started out with the idea of trying to get all 480 front and back 4-runs 
into a reasonably short length that someone might actually want to ring.

How closely packed can the runs be?  Of course one can repeat a run 
immediately with e.g. a 5678 place notation:
12345678
21435678
but while that's a potentially interesting effect, I decided I wanted to 
try to stick to more conventional local structure (e.g. maybe all triple 
and quadruple changes).  Of course one can repeat runs every other row 
using dodging:
12345678
21436587
24135678
42316587
43215678...
but more than a triple dodge or so would get boring, and one must link to 
other types of run.  In a few cases one can go directly to another type, 
e.g.
21435678
12346587
or
24315678
23451768
but there are not many such opportunities.  Many more linkages open up if 
one allows things like the following, where two run-rows are separated by 
two other rows, with both the run type and direction changing:
12834567
21384657
23148675
32418765

Based on this, it might be reasonable to have no more than two other rows 
between two run-rows in the entire touch.  However, I couldn't think of an 
obvious way to impose enough structure to make this into something 
sensible rather than a long random string of place notation.

An obvious solution to the structure issue is to aim for a cyclic 8-part. 
It is no longer reasonable to expect the property above, but instead one 
can still hope for at most two other rows between potential run-rows, i.e. 
run-rows plus things like -7812 that will become a run-row in other parts.

My first attempts involved starting from simple basic blocks.  E.g. here 
is a natural set of round blocks that together contain all the runs, if 
rung 8 times each according the cyclic part ends 23456781 etc.:
12345678: -4.5.6.5.4-4-4-3.6.3-4-4 *3
13245678: -4.5.6.5.4-4-4-3.6.3-4-4 *3
12345678: -5.4.3.4.5-5-5-6.3.6-5-5 *3
12345768: -5.4.3.4.5-5-5-6.3.6-5-5 *3
The problem is that these are false against each other in multiple places. 
E.g. rounds and 43215678 each occur in two blocks because they each 
contain two runs, but so does 43216587 because it appears both as a 1234 
run and as a link row for 5678 runs.  This kind of thing seems inevitable 
whenever one starts with simple repeating blocks.  Falseness is not 
necessarily a problem, because one can eliminate it by local changes, and 
potentially even use it to link blocks together.  However, the very nature 
of the shared runs issue requires different solutions in different places. 
E.g. starting from the above blocks, here is a true set of round blocks I 
found that contain all the runs in a cyclic 8-part structure, retaining 
rotational symmetry (more on that later):
43125678: 5.6.5.4-4-4-6.3-5-5-5.4.3.4.5-5-5-3.6-4-4-4
32145678: 4-4-4-3.6-5-5-5.36.45.36.4-4-4-3.6-5-5-5.36.45.36
42135678: 56.1-5-5-5.4.3.4.5-5-5-1.56.4-4-4-36.1.36-4-4-4
34215678: 1.34.5-5-5-36.1.36-5-5-5.34.1-4-4-4.5.6.5.4-4-4-
21438765: 4-4.5-5.4-4.5-5
43216587: 4-4.5-5.4-4.5-5
43215678: 4-4.5-5.4-4.5-5
43218765: 4-4.5-5.4-4.5-5
These still need to be joined together, and the 8 parts need to be joined 
somehow.  One could certainly do this, but it would probably end up not 
very elegant, with little sign of the original structure.  Getting an 
exact 8-part would be difficult without an ugly and perhaps run-free link 
section.

I decided to abandon the method-based approach and simply look for an 
8-part, hopefully an exact one.  It turns out that there is still enough 
room for manoeuver in the graph containing all potential run-rows plus 
links between them involving at most 2 other rows.  I investigated the 
possibilities, but the problem is that there is too much flexibility.  An 
arbitrary 1/8th quarter peal length string of place notation is a lot to 
learn, and not very satisfying.  I needed to impose more structure.

One potential improvement is a 16-part, with the part ends being the 
cyclic ones 23456781 etc. plus their reverses  (which form a dihedral 
group, isomorphic to plain hunt).  I thought it might be possible to have 
a symmetric 8-part, with a forward part end part followed by a reverse 
part end one rung in reverse, but I can't see how to do this without 
asymmetric (and perhaps run-free) links between them, which isn't good.

There is another way to get more symmetry - rotational symmetry.  Suppose 
our part starts something like
    *12345678*
58  21435768
x   12347586
16  13274568
...
Then one can ring the same place notations reversed and in reverse order 
at the end of the part:
...
     13452768
38  31425678
x   13246587
14 *12345678*
58  21435768
x   12347686
16  13274568
...
With the chosen part ends (and no others), any potential run-row in one 
half will become a potential run-row in the other half, with runs at the 
front becoming into runs at the back and vice versa.  And this will 
effectively turn the touch into a 32-part, with only half as much place 
notation to be learned and searched for.

How does one avoid falseness in such a scheme?  Every row has a 'partner', 
which is the one that we want to occur in the corresponding place in the 
other half of the part.  E.g. the partner of 12345867 is 23145678.  And 
taking partners respects the 16-part structure.  (Mathematically the 
partner is the conjugate by reverse rounds R, and if P is a part end then 
R(PA)R = P'(RAR) where P' = RPR which is another part end since R is in 
the normalizer of the part end group).

Here there is a delicate issue.  Some rows are their own partner. 
Fortunately there are only two (modulo the 16 parts): rounds and 43215678. 
(In an 8-part it would be rounds and backrounds).  Therefore we must use 
these as the apices.  So what we want is a block starting from rounds and 
ending at 43215678 (or its equivalent in some other part), visiting either 
each other run-row or its partner (but not both).  Then we reverse this 
block both in space and time to get back again and obtain one rotationally 
symmetric part.  An inevitable consequence of this is that the part end 
after one part must be 43218765.  On the face of it this is not ideal, 
because then there will be 8 round blocks to be joined together somehow. 
But things will in fact turn out well...

After some experimentation with different place notation selections and 
requiring a decent amount of traffic through 45 to avoid stagnation, I 
came up with block B, which I was pretty happy with.  The different run 
types are nicely mixed, with often 2 or 3 immediate repetitions of the 
same type using dodges, but no more.   Only good place notations appear 
(unless you object to 34 and 56, in which case I don't think there is much 
hope here). There are some other options, but not that many, particularly 
as short as this.  As described above, the block is rotationally 
symmetric, and 8 copies of the round block BB give all the rows we want.

That leaves the problem of joining the blocks.  Initially I was not 
optimistic about doing this elegantly.  The rather frenetic place notation 
means one should not expect that many Q-sets, especially without long 
places, and there is the danger of getting e.g. to the part end 34567812, 
so that one still has more joining to do.

However, a miracle occurs.  There is a magical Q-set present that involves 
all of the place notations 16,38,18,36 and preserves the rotational 
symmetry!  Replacing the original 38 with 18 shunts to the corresponding 
place in the second half of the block, and we get back again by replacing 
16 with 36, so only 2 blocks are joined, and we don't get a parity 
problem.
12348657  12348576
21384567  13284567
becomes
12348657  12348576
13284567  21384567
and we never need to interrupt the run-fest.  Amazingly, the surrounding 
place notations are such that we (just) avoid long places.  Furthermore, 
one shunt gets to 45678123, so no other link types are required.  Many of 
us know that these things rarely work out so nicely!

Incidentally, I don't think I have ever seen this type of Q-set used 
before.

At this point it's easy: we just successively link the blocks with 7 such 
Q-sets.  The whole touch has exact rotational symmetry.  It is amusing 
that the A and C parts have odd length, so alternate part ends come at 
handstroke.  I really find it amazing that all this works!

What's the best way to describe this touch?  As I have tried to argue, I 
think this should be entirely at the discretion of any band that wants to 
ring it.  One-size-fits-all attempts to legislate simply get in the way of 
new ideas like this.

However, if one wants to think in terms of methods, one suggestion (among 
other possibilities) is the following.  It has the advantage of just two 
rotationally symmetric methods that don't look too daunting (a principle, 
and a short 11222 differential), and lead-end calls.  The drawback is that 
the lead-end orders are unintuitive, and the cyclic structure gets rather 
severely hidden in this description.

Frog Major:
-4-34.6.5.6-4-4.56.1.56.4-34-3.6.5-56.4.36-4.56.1.34.1.34.5-34.
56-4.56.1.56.1.34.5-36.5.34-4.3.6-56-5.34.1.34.5-5-3.4.3.56-5-1
l.e. 57628413
bob = 3

Toad Differential Major:
4-4-6.3.56.34.1.34-5.4-56.1.56.34.6.3-5-5.36
l.e. 13254876
bob = 6

       12345678
       --------
(F)   35426781
F     68751234
F     13284567
F_T_  64573218
F_TT_ 31248765
F_TT_ 86715432
F_TT_ 53462187
F_TT_ 28137654
F_TT_ 75684321
F_TT_ 42351876
F_TT_ 17826543
F_T_  46537812
F     71862345
F     24315678
F     57648123
F     82173456
(F)   12345678
       --------
Start and finish at the half-lead of Frog: 56-4.56.1...