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

Alexander Holroyd holroyd at math.ubc.ca
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

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...

```