[r-t] Jump change notation

[Don Morrison]

I'm currently tidying up and revising the place notation parsing code
I use. It does handle jump changes, though in a rather brute force
manner, by simply embedding the full permutation like a row within
square brackets in the place notation. Thus the first few changes of
Cambridge Treble Jump are

x3x[134265]x2

While unambiguous, it does not seem to correspond with what others do,
and is probably less compact for most real cases, as well as possibly
lacking other useful properties. So I'm thinking about possibly
adopting something different.

Long term, meeting a need Philip Earis voiced, I'm also hoping to
update my blue line drawing code to support jump changes.

I'm aware of three conventions folks use to notate jump changes.

1) The above, rather heavy hammer.

2) Embedding cycles of positions in parentheses within place notation,
as is done on <http://wiki.changeringing.co.uk/Jump_change_methods>.
In this scheme the above fragment would (I think) be

x3x(243)x2

3) Embedding each jumping position as a source and target pair within
parentheses as Ander described a couple of months ago:

On Mon, Mar 23, 2015 at 6:46 AM, Alexander Holroyd <holroyd at math.ubc.ca> wrote:
> On notation, since jump methods tend to have relatively few and
> small jumps, I like using (xy) for a jump from place x to place y
> (where |x-y|>=2), and as usual z for zths place made, so e.g.
>
> (13)4 denotes
> 23146587
>
> (13)(31)8 or (13)(31) denotes
> 32154768
>
> (13)(42) denotes
> 24136587
>
> I think it's true (but perhaps not completely obvious) that there is
> always at most one way to fill in the remainder of such a change
> with non-jumping bells.

In this scheme the above fragment would (I think) be

x3x(24)x2

Does anyone have any sense of how popular each of these schemes is?

Scheme (3) appears to have the attractive property that it is
immediately explicit which positions are jumping. For things like
Treble Jump it is also quite compact. For more general jump changes
(2) may be more compact, however.

Any further reasons for preferring one over another?

Two further issues I've not seen discussed are (a) canonical versions
of the various possibilities, and (b) reversals and palindromes. They
are also to some extent related issues.

Regarding (a): for normal changes we always write the bells held fixed
in lexicographic order. There's no particular reason we couldn't write
the first few changes of Cambridge Surprise Major as x83x41x2851x if
we were so minded; but convention says we don't do that.

This is not an issue for scheme (1), above, but it is for (2) and (3).
There is both the issue of in which order we write the various
parenthesized expressions, and the order of the bells within them. I
think one possible convention for scheme (2) would be to always write
the cycles such that of those remaining, that containing the lowest
position comes next, where we consider an unparenthesised place being
made as a cycle of length 1; and within the cycles, to rotate them so
that the lowest position always comes first. Does this make sense? Is
it natural? Note that in (2) any cycles can be rotated without
affecting meaning (I think).

For scheme (3) there is no ambiguity within the parenthesised pairs, the
only thing that we may choose to canonicalise is the order of the various
pairings. A possibility is to arranging things so that the first named
bell is arranged in lexicographic order along with the places being made.
Does this make sense? Is there a better alternative?

Regarding issue (b), we are in the habit of simply reversing sequences
of changes. This only works because ordinary, non-jump changes are
always self-inverse (some jump changes are, too, but in general they
are not). Thus, while using scheme (3), the first half lead of Cambridge
Treble Jump can be written (I think):

x3x(24)x2x(35)x4x5

the second half lead is NOT, as I suspect many ringers my naively assume
from the usual practice with non-jump changes

x4x(35)x2x(24)x3x2

rather it is (I think)

x4x(53)x2x(42)x3x2

Is it true that in scheme (3) we can always reverse things by
combining the reversal of the sequence of changes with the reversal of
the pairs within parentheses? If so, while this works out nicely for
Cambridge Treble Jump Minor, for more complicated cases I believe the
intermixing of bells making places with the jumping pairs will disrupt
a lexicographic canonicalisation as described above. Is there a better
way forward?

Similarly, I think reversing things in scheme (2) can be accomplished
simply by reversing the contents of the various cycles. Is this right?
If so, again the canonical form gets messed about, though, both
because of the ordering of the cycles and bells making places, and
also the ordering of the various bells within the cycles.

Also related to issue (b): there are various conventions for extending
place notation to indicate an unfolding operation, quite useful for
the usual methods with palindromic symmetry. I think the convention
adopted in recent CCCBR collections, of a comma appearing between to
pieces of place notation, each unfolded (about a change, not about the
interstice between a pair of changes) and the results appended, is
quite graceful and fits well with the usual needs.

In the presence of jump changes ought we simply to retain such a
convention, with the proviso that those changes appearing in the
reversed portion are all inverted? For ordinary changes, inversion
obviously makes no difference, but for jump changes it typically does.
Thus, with this convention, we could notate a full lead of Cambridge
Treble Jump Minor as

x3x(24)x2x(35)x4x5,2

which would expand to

x3x(24)x2x(35)x4x5x4x(53)x2x(42)x3x2

Does this make sense? Are there any dragons lurking in the corners?
What happens if the apex (e.g. half-lead) change is a jump change? For
example, the little plain minor method (written according to scheme
(3)):

x2(35),1

does NOT have palindromic symmetry, despite having been written in a
form that would normally imply that it does. Perhaps such an unfolding
convention can be retained with the additional restriction that the
apices must not be jump changes? Or may be jump changes, but must be
self-inverse? (In my existing code I disallow mixing jump changes with
comma at all, but that seems more Draconian than necessary.)

A different matter: while it is trivially easy in scheme (1), it is
not clear to me what an appropriate algorithm is for turning things
written according to schemes (2) or (3) into the usual permutations,
particularly when allowing leading and lying places to be elided. That
is, after slotting in any explicitly described jumping and place
making bells, slotting in the rest as non-jumping bells (e.g. in
scheme (3), turning the royal change (35)(96) into 2145396780 -- note
that far more complicated arrangements are also possible). Any
thoughts?

I welcome any corrections to my understanding, and suggestions for
good ways forward.



-- 
Don Morrison <dfm at ringing.org>
"The universe may be as great as they say. But it wouldn't be
missed if it didn't exist."        -- Piet Hein, _Grooks_