# [r-t] Changes v. rows

Don Morrison dfm at ringing.org
Mon Aug 11 03:56:30 UTC 2008

```This may be a complete non-issue, but I haven't quite figured out
whether or not I think it is relevant.

On Sun, Aug 10, 2008 at 7:09 PM, Mark Davies <mark at snowtiger.net> wrote:
> OK, here's the latest. I don't know, you might like this!
>
> A peal is true if:
>
> 1. It is rung on one stage, and each change in the extent at  this stage is
> rung either N or N+1 times in the peal, and no more, for N>=0.
>
> 2. It is rung on two stages, A and B, where |B-A|=1, and each change in the
> extent on A is rung M times in the peal, and no more, and each change in the
> extent on B is rung N or N+1 times, and no more, for M>0 and N>0.
>
> 3. In a two-stage peal, the structure of the composition should make clear
> which changes are treated at which stage.
>
> 4. For the purposes of proof in (1) and (2) above, methods at any lower
> stage may be considered rung at a higher stage by: (a) including leading or
> covering bells; (b) ringing two or more methods at a lower stage in
> parallel; or (c) both of the above.

Presumably in 1 and 2 you are using "change" in the informal sense we
usually do use it, and if being more precise you would say "row".

For the easy, single stage case truth clearly is simply a property of
the rows rung. Is that right?

Methods and compositions are essentially structures of changes, that
applied successively to the distinguished starting row produce a
sequence of rows. So for parts 3 and 4 it really is about changes,
right? Or at least, some mixture I can't quite get my head around of
the changes producing the rows we're trying to compare to one another
for distinctness and those rows.

What is the change at each point we are switching between stages? In
normal, single stage spliced a row is produced by a change from the
method we are leaving, but that row is the first row "of" the method,
even though methods are (I think) really composed of changes, not
rows. What happens in multi-stage spliced? If we are going from the
higher stage to a lower stage the perspective of ordinary spliced
makes sense. But what if we are going from the lower stage to the
higher stage? It can't be the lower stage change producing the higher
stage row. Is it just the lower stage change extended to the higher
stage by implicitly adding fixed positions in the permutation that is
the change?

I think this is probably irrelvant, but I'm not sure. Is it? Or is
there something meaningful here?

--
Don Morrison <dfm at ringing.org>
"Failure is not an option. It comes bundled with the software."
-- from a T-shirt

```