Max-Variety-3 Scales, and a Conjecture

I have a conjecture about max-variety-3 scales. Check out keenan's post on tuning math for basic background information:
https://groups.yahoo.com/neo/ groups/tuning-math/ conversations/topics/19334 https://groups.yahoo.com/neo/groups/tuning-math/conversations/topics/19334

It is possible to uniquely specify a max-variety-2 scale by listing multiplicities of steps (let's call these stencils). For example, the stencil (5, 2) uniquely corresponds to the structure [aabaaab].

With max-variety-3 ("MV3" from here on) scales this luxury is simply not possible. For instance, the stencil (2, 2, 1) can either be [abcba] or [abcab]. Therefore some stencils can represent more than one structure. Let us call these ambistencils, because they are ambiguous.

Conjecture:
(2, 2, 1) is the only MV3 ambistencil with a prime number of notes.

Corollary #1:
Every MV3 ambistencil besides (2, 2, 1) has a factor which divides all of the multiplicities of each step size, (assuming that the repetitions of (1, 2, 4) can never be ambistencils).

Corollary #2: (not completely sure if this is a corollary?)

(2, 2, 1) is the only MV3 ambistencil with a step size that only appears once.

Ryan Avella

Hi Ryan,

thanks for sharing your observations! I found them very insightful,
and they inspired me to continue investigating MV3 scales again. :)

What I don't understand is how corollary #1 follows from the conjecture.
On the contrary, I can clearly see how corollary #1 implies the conjecture.
So maybe "corollary #1" should be a conjecture, and the "conjecture"
a corollary that follows from it?

In addition, I don't see why the assumption in corollary #1 about repetitions
of (1, 2, 4) should be relevant:
If they can be ambistencils, then corollary #1 makes a correct statement about
them, and if they can't, corollary #1 doesn't make a statement about them at all,
so it shouldn't matter.

Does this make sense, or did I make an error in reasoning?

- Geddy

I think I might have found an algorithm that generates MV3 scales. I still have to test if the results are completely consistent with the list of MV3 scales with up to 31 notes, and some proofs will have to be made, but even if there are flaws, I think it makes for a useful basis.

Beforehand a definition, and some consequences concerning stencils (1) and ambistencils (2) if the algorithm actually reliably generates all MV3 scales:

Definition:
A stencil is a triple (x, y, z) with integers x >= y >= z > 0, where x, y and z represent multiplicities of the three different step sizes a, b and c. Because a, b and c are not specified, scale patterns with those letters interchanged are equivalent.
|(x, y, z)| is the number of the scale patterns associated with (x, y, z) that represent a class of MV3 scales.
Examples:
(i) |(3, 2, 1)| = 0 (no MV3 scales)
(ii) |(1, 1, 1)| = 1 (single MV3 scale pattern => not an ambistencil)
(iii) |(2, 2, 1)| = 2 (two MV3 scale patterns => an ambistencil)

1) Keenan's conjecture 1:
|(x, y, z)| >= 1 if and only if one of the following applies:
(i) x = y
(ii) y = z
(iii) (x, y, z) is a multiple of (4, 2, 1)

2) Ambistencils:
|(x, y, z)| >= 2 if and only if one of the following applies:
(i) (x, y, z) = (2, 2, 1)
(ii) x = y = z >= 2
(iii) x = y, gcd(y, z) > 1, and gcd(2y, z) divides y
(iv) y = z, gcd(x, y) > 1, and gcd(x, 2y) divides y

Notice that 2) (iii) and (iv) can be combined as following:
(x = y or y = z), gcd(y, n) > 1, and gcd(2y, n) divides y, where n := x+y+z

=============================================

The (rough) algorithm for a given stencil (x, y, z):

if (x, y, z) is a multiple of (4, 2, 1), return repetition of 'aabacab', and exit
if x = y {
- if (x, y, z) is a multiple of (2, 2, 1), return repetition of 'aabcb'
- if y = z, generate and return patterns of type 1 (instructions follow), and exit
- generate and return patterns of type 2 (instructions follow), and exit
}
if y = z, generate and return patterns of type 3 (instructions follow)

Generating patterns of type 1 to 3:

Type 1: (y, y, y)
-----------------------
Generate all words over the alphabet {'d', 'e', '[', ']'} with a word length of y, using the following rules:

Start: {'d', '[]'}
'[]' -> '[][]'
'[]' -> '[e]'
'][' -> ']d['
'd' -> 'dd', 'e' -> 'ee'

...where:

'[' := 'aba'
']' := 'cbc'

'd' := 'abc' 'e' := 'cba'

...so valid words are either repetitions of 'd', or consist of alternating pairs of square brackets that may contain any number of 'e's, or which may be adjacent to any number of 'd's.

Then, remove "duplicates", i.e. words that (or whose reflections) are translation-symmetric to a previously generated word.
Note: When mirroring a word, '[' and ']' stay as they are, and 'd' and 'e' are interchanged.
Also, don't forget that interchanging a, b and c is always allowed, so 'ddd' and 'eee' are the same!

Example: The resulting words for (7, 7, 7), after removing duplicates, are:
'[eeeee]', '[eeee]d', '[eee][]', '[eee]dd', '[ee][e]', '[ee][]d', '[ee]d[]', '[e][e]d', '[e][][]', 'ddddddd'

Which become: 'abacbacbacbacbacbacbc', 'abacbacbacbacbacbcabc', ...

Type 2: (y, y, z), y != z, excluding repetitions of (2, 2, 1)
-----------------------
Step 1: (generate primary pattern)
- create MOS pattern with 2y steps '#', and z steps 'c'
- replace the '#'s alternately with 'a' and 'b'

Example 1:
For (5, 5, 3), the (10, 3)-MOS pattern is '####c###c###c'. By inserting 'a' and 'b' alternately, it becomes 'ababcabacbabc'.

Example 2:
For (6, 6, 3), the (12, 3)-MOS pattern is '####c####c####c', which gives 'ababcababcababc'.

Step 2: (derive other patterns, if possible)
- if gcd(y, z) = 1 or gcd(2y, z) doesn't divide y, exit
(I'm pretty uncertain about the following part...)
- start with the MOS pattern (the one with '#'s and 'c's), fix one 'c', and swap any other 'c' with an adjacent '#' (only one swap per 'c', same direction for all 'c's). Resulting patterns are valid, if either
a) there the chains of '#'s in the original MOS pattern have two distinct lengths, and the chains in the resulting patterns have the same lengths, or
b) if all chains of '#'s in the original MOS pattern are of equal length l, and no chain in the resulting pattern is longer than l+1 or shorter than l-1. - remove duplicates (translational equivalent patterns)
- insert 'a's and 'b's in the remaining valid patterns, as described in step 1

Example 1 (continued):
For (5, 5, 3), gcd(y=5, z=3) = 1, so no further patterns exist for this stencil.

Example 2 (continued):
For (6, 6, 3), gcd(y=6, z=3) != 1, and gcd(2y=12, z=3) = 3 divides y=6, so there are further patterns. If we fix the rightmost 'c' in '####c####c####c', we can swap the first, the second, or both 'c's with it's right neighbour. The results are '#####c####c###c', '#####c###c####c' and '####c#####c###c', all of which are valid, though the third one is translationally equivalent to the second one, and therefore removed.
When inserting 'a's and 'b's, we get 'ababacbabacbabc' and 'ababacbabcababc', in addition to the primary pattern.

Type 3: (x, y, y), x != y
-----------------------
Step 1: (generate primary pattern)
- create MOS pattern with x steps 'a', and 2y steps '#'
- replace the '#'s alternately with 'b' and 'c'

Example: For (6, 2, 2), the (6, 4)-MOS pattern is 'aa#a#aa#a#'. By inserting 'b' and 'c' alternately, it becomes 'aabacaabac'.
Step 2: (derive other patterns, if possible)
- if gcd(x, y) = 1 or gcd(x, 2y) doesn't divide y, exit
- do the same as in step 2 for type 2, except treating the step with more occurances in the original MOS pattern as a '#', and the one with fewer occurances as a 'c'. In addition, here it can happen that two of the step with fewer occurances become adjacent, which results in an invalid pattern.
- in the last step, insert 'b's and 'c's

Continued example - (6, 2, 2):
gcd(x=6, y=2) != 1, and gcd(x=6, 2y=4) = 2 divides y=2, so we can go on.
In 'aa#a#aa#a#', 'a'-chains come in two lengths, so in resulting patterns the chain lengths must be the same. The only valid result is 'aa#aa#a#a#', giving 'aabaacabac'.

Best
- Gedankenwelt ("Geddy")