Recursive structure of MOS scales

From Xenharmonic Wiki
Jump to navigation Jump to search

By looking at the "tetrachords" L…s of an MOS scale in word form and giving them the names "L" and "s", we get out another MOS scale. The MOS thus obtained preserves a number of important properties, such as which interval is the generator. To find properties of complex MOS word patterns, we can then just compare them to the simpler ones, whose properties we know.

Recursive structure

Chunking operation

Let w be an arbitrary moment-of-symmetry scale in either its brightest mode (where L's come before s's) or darkest mode (where s's come before L's). Let x be the number of L's in the scale and let y be the number of s's in the scale. Such a scale will fall under one of three general cases or one of three special cases described below.

General cases

  • Case 1: The scale is a single-period moment-of-symmetry scale where there are more L's than s's, and there is more than one s (or x > y > 1). Scale w can broken up into y substrings (or chunks) where each substring contains at least one L and exactly one s. Among these chunks, there are two unique chunks whose sizes differ by exactly one L: the larger of the two contains ceil(x/y) L's and exactly one s, and the smaller of the two contains floor(x/y) L's and exactly one s.
  • Case 2: The scale is a single-period moment-of-symmetry scale where there are more s's than L's, and there is more than one L (or y > x > 1). Scale w can broken up into x substrings (or chunks) where each substring contains at least one s and exactly one L. Among these chunks, there are two unique chunks whose sizes differ by exactly one s: the larger of the two contains ceil(y/x) s's and exactly one L, and the smaller of the two contains floor(y/x) s's and exactly one L.
  • Case 3: The scale is a multi-period moment-of-symmetry scale. Because a multi-period scale consists of a single MOS-like chunk that's repeated throughout the scale, x and y necessarily share a common factor c, where c is the greatest common factor of x and y, and c is the number of times that chunk is repeated. Therefore, when considering a multi-period moment-of-symmetry scale, only the first chunk, the first (x+y)/c steps of the scale, needs to be considered. This chunk will fall under case 1 or case 2, or one of the special cases.

Special cases

  • The special case for case 1 is when there is only one s in the scale. The scale is a moment-of-symmetry scale where the entire scale is considered to be one chunk.
  • The special case for case 2 is when there is only one L in the scale. The scale is a moment-of-symmetry scale where the entire scale is considered to be one chunk.
  • There is a third special case where there is exactly one L and one s in the scale, producing "Ls" or "sL". Technically speaking, it's possible to reduce the previous two special cases even further into this special case.

In both case 1 and 2, the L's and s's are distributed such that they are maximally even (that is, they are distributed as evenly as possible), but the chunks of L's and s's are arranged so that they too are maximally even. This can be demonstrated by reducing the larger chunks into L and the smaller chunks into s. This produces a new scale W that is also a moment-of-symmetry scale. This process can be repeated multiple times until the scale is reduced into one of the special cases. In case 3, it is possible to reduce a multi-period scale until it consists of a single unique MOS-like chunk repeated c times, where that chunk is one of the special cases.

Note that in this reduction process, the order of L's and s's may reverse. This is normal.

Reversing the reduction rules into production rules

Just as reducing a moment-of-symmetry scale using the aforementioned process produces another moment-of-symmetry scale, reversing the reduction rules into production rules will produce another scale w' that is also a moment-of-symmetry scale. One of the following sets of production rules can be used:

  • L -> LL...LLs (n+1 L's and one s), s -> LL...LLs (n L's and one s)
  • L -> ss...ssL (n+1 s's and one L), s -> ss...ssL (n s's and one L)
  • L -> Ls, s -> s (a special case of the first set of productions rules where n = 0)
  • L -> sL, s -> L (a special case of the second set of productions rules where n = 0)

Repeating these production rules will produce a scale that is more chromatic than the last, and every scale produced this way is another moment-of-symmetry scale.

The recursive nature of moment-of-symmetry scales allows for two algorithms to be made: one that can determine whether an arbitrary scale of large and small steps is a valid moment-of-symmetry scale and another that can construct a moment-of-symmetry scale from any number of large and small steps, without any prior knowledge of the scale's structure.

Determining whether a scale has the MOS property

General algorithm

Stepwise version

This is the general algorithm for determining whether a scale is maximally even (that is, it is a valid MOS). This version of the algorithm that uses the production rules in reverse: L -> Ls and s ->s; and L -> sL and s -> L. It is required to perform this on the string that represents the scale in its brightest mode. This algorithm is recursive.

  1. Count how many L's and s's there are within the string. Let x be the number of L's and y be the number of s's. One of two situations will happen:
    1. If both x and y are equal to 1, then the scale is maximally even.
    2. If x and y share a common factor k (that is, x and y are not coprime), then the scale is a multi-period scale. Split the string into k substrings that are exactly (x+y)/k characters long. If all of the substrings are identical, then perform the algorithm corresponding to that substring to determine whether the substring is maximally even. If it's not the case that all of the substrings are identical or the substring is not maximally even, then the scale is not maximally even.
  2. If there are more L's than s's AND there are either at least two adjacent s's or an s is at the beginning and end of the string, then scale is not maximally even. If there are more s's than L's AND there are either at least two adjacent L's or an L is at the beginning and end of the string, then the scale is not maximally even. This is because between every two instances of the character that appears the least must be at least one instance of the character that appears the most; this also applies if the character that appears the least appears at both ends of the string, as a different mode of the same string will put those two characters next to another.
  3. Split the string into a sequence of chunks as described: if there are more L's than s's (or if x > y), then each chunk will consist of at least one L followed by exactly one s; if instead there are more s's than L's (or y > x), then each chunk will consist of exactly one L followed by at least one s. Preserve the order of these chunks.
  4. Count how many UNIQUE chunks there are. If there are more than two unique strings, then the scale is not maximally even. If there are only two unique strings but their lengths differ by more than 1, then the scale is not maximally even.
  5. If there are more L's than s's, then for each chunk, replace all but the last two characters with s's, and replace the last two characters with a single L. This process represents L->sL and s->L. If there are more s's than L's, then for each chunk, replace only the first two characters with a single L. This process represents L->Ls and s->s, but reversed. The scale produced this way is the parent scale.
  6. Repeat the algorithm recursively on the parent scale. If that scale is maximally even, then the original scale is maximally even.

Chunking version

This is the general algorithm for determining whether a scale is maximally even (that is, it is a valid MOS). This version of the algorithm reduces entire chunks into L's and s's based on the size of the chunks. It is recommended, but not required, to perform this on the string representing the scale in either its brightest or darkest mode. This algorithm is recursive.

  1. Count how many L's and s's there are within the string. Let x be the number of L's and y be the number of s's. One of two situations will happen:
    1. If either x or y is equal to 1, or both x and y are equal to 1, then the scale is maximally even.
    2. If x and y share a common factor k (that is, x and y are not coprime), then the scale is a multi-period scale. Split the string into k substrings that are exactly (x+y)/k characters long. If all of the substrings are identical, then perform the algorithm corresponding to that substring to determine whether the substring is maximally even. If it's not the case that all of the substrings are identical or the substring is not maximally even, then the scale is not maximally even.
  2. If there are more L's than s's AND there are either at least two adjacent s's or an s is at the beginning and end of the string, then scale is not maximally even. If there are more s's than L's AND there are either at least two adjacent L's or an L is at the beginning and end of the string, then the scale is not maximally even. This is because between every two instances of the character that appears the least must be at least one instance of the character that appears the most; this also applies if the character that appears the least appears at both ends of the string, as a different mode of the same string will put those two characters next to another.
  3. Split the string into a sequence of chunks, not by splitting the strings into chunks that contain L's and s's, but AT the character that appears the least. Because every chunk contains at least one L and at least one s, removing the character that appears the least will not make any difference to how the chunks are ordered in terms of size. If there are more L's than s's, then there should be exactly y chunks consisting of only L's, and if there are more s's than L's, then there should be exactly x chunks consisting of only s's. If there is exactly one more string than expected, this may be because the string was in a mode that split one of the chunks into two; in this case, combine the first and last chunks in the sequence back into one chunk to get the correct number of chunks.
  4. Count how many UNIQUE chunks there are. If there are more than two unique strings, then the scale is not maximally even. If there are only two unique strings but their lengths differ by more than 1, then the scale is not maximally even.
  5. Produce a new scale consisting of L's and s's, based on the sequence of tokenized strings, as this will be the progenitor scale of the original; in the sequence, every instance of the larger string corresponds to an L in the progenitor scale, and every instance of the smaller string corresponds to an s in that scale. Call this algorithm recursively on that scale to determine whether that scale is also maximally even. If that scale is maximally even, then the original scale is maximally even. Otherwise, the scale is not maximally even.

Pseudocode

This is the pseudocode for the chunking operation described above.

VerifyMaximallyEvenScale(string scale : scale encodes an arbitrary scale of only L's and s's) returns TRUE or FALSE {

	integer x = 0;
	integer y = 0;

	for (integer i = 0 to scale.length) {
		if (scale[i] == x) {
			x += 1
		} else if (scale[i] == y) {
			y += 1
		}
	}

	// This is a separate function that returns the greatest common factor between x and y
	// This should return 1 if x and y are coprime
	integer common_factor = FindLargestCommonFactor(x, y)

	if (common_factor > 1) {
		set<string> substrings = { }

		integer length_counter = 0
		string temp_string = ""
		for (integer i = 0 to x + y) {
			length_counter += 1
			temp_string += scale[i]
			if (length_counter == common_factor) {
				length_counter = 0
				set.add(temp_string)
				temp_string = ""
			}
		}
		
		if (set.size != 1) {
			return FALSE
		} else {
			string subscale = set.beginning_of_set
			return VerifyMaximallyEvenScale(subscale)
		}
	}

	if (x == 1 OR y == 1) {
		return TRUE
	} else {
		if (x > y) {
			if (scale.contains_substring("ss") OR (scale[0] == "s" AND scale[s.size-1] == "s") return false
		} else if (y > x) {
			if (scale.contains_substring("LL") OR (scale[0] == "L" AND scale[s.size-1] == "L") return false
		}

		array<string> tokenized_strings = []

		// TokenizeString is a separate function that tokenizes a string at a specific character
		// Actual code may vary based on programming languages or libraries, but for the sake of
		// pseudocode, it's represented as a function that returns an array of tokenized strings
		if (x > y) {
			tokenized_strings = TokenizeString(string, 's')
		} else if (y < x) {
			tokenized_strings = TokenizeString(string, 'L')
		}

		integer string_count = min(x, y)

		if (tokenized_strings.length = string_count + 1) {
			tokenized_strings[0] = tokenized_strings[0] + tokenized_strings[string_count]
			tokenized_strings.remove_element_from_end()
		}

		set<string> unique_strings = { }

		for (integer i = 0 to string_count ) {
			unique_strings.add(tokenized_strings[i])
		}

		if (unique_strings.size != 2) {
			return FALSE
		} else {
			// A set should order things in alphabetical order, so string_1 and string_2
			// should represent the smaller and larger of the strings respectively
			string string_1 = unique_strings.beginning_of_set
			string string_2 = unique_strings.end_of_set

			if (abs(string_1.length - string_2.length) != 1) {
				return FALSE
			} else {
				string subscale = ""

				for (integer i = 0 to tokenized_strings.length) {
					if (tokenized_strings[i] == string_1)
						subscale += "s"
					else if (tokenized_string[i] == string_2)
						subscale += "L"

				return VerifyMaximallyEvenScale(subscale)
			}
		}
	}
}

Examples

6L 1s, or LLLLLLs. This falls under one of the special cases and is a moment-of-symmetry scale.

1L 6s, or Lssssss. This falls under one of the special cases and is a moment-of-symmetry scale.

5L 2s, or LLLsLLs. This produces two unique chunks of LLLs and LLs; replacing them with L and s respectively reduces the scale into Ls and is a moment-of-symmetry scale.

2L 5s, or LssLsss. This produces two unique chunks of Lss and Lsss; replacing them with s and L respectively reduces the scale into sL and is a moment-of-symmetry scale.

5L 7s, or LsLsLssLsLss. This produces two unique chunks of Ls and Lss; replacing them with s and L respectively reduces the scale into ssLsL. That scale produces two unique chunks of ssL and sL; replacing them with L and s respectively reduces the scale into Ls and is a moment-of-symmetry scale.

7L 5s, or LLsLsLLsLsLs. This produces two unique chunks of LLs and Ls; replacing them with L and s respectively reduces the scale into LsLss. That scale produces two unique chunks of Ls and Lss; replacing them with s and L respectively reduces the scale into sL and is a moment-of-symmetry scale.

5L 4s, or LLsLsLsLs. This scale consists of two unique chunks of LLs and Ls; replacing them with L and s respectively reduces the scale into Lsss and is a moment-of-symmetry scale.

3L 6s, or LssLssLss. Since 3 and 6 share a common factor of 3, this scale consists of Lss repeated three times, which falls under the special cases and is a multi-period moment-of-symmetry scale.

Counterexamples

LLLLsLs. This produces two unique chunks of LLLLs and Ls. However, the two chunks differ in size by two L's, and it is not maximally even.

LLLLLss. This produces one chunk of LLLLLs. The lone s at the end can be considered a chunk consisting of zero L's and one s. Since the two chunks differ in size by 5 L's, this is not maximally even.

LsssLsssL. The quantity of L's and s's are coprime, sharing a common factor of 3. However, dividing the scale into three equal-sized chunks shows that all three chunks are different (Lss, sLs, and ssL), so this is not maximally even.

LLsLLLsLLLLs. This produces three unique chunks of LLs, LLLs, and LLLLs. This is not maximally even.

Finding the MOS pattern from xL ys

General algorithm

This is the general algorithm for generating a moment of symmetry scale of the form xL ys represented as a string of L's and s's in its brightest mode. This algorithm will produce that scale without any prior knowledge of how the scale's steps are ordered. This algorithm is recursive. Let x be the number of L's and y the number of s's.

  1. If either x or y is equal to 1 (base cases):
    1. If both x and y are equal to 1, then the final scale is "Ls".
    2. If only x is equal to 1, then the final scale is L followed by y s's.
    3. If only y is equal to 1, then the final scale is x L's followed by s.
  2. If neither x nor y is equal to 1 (recursive cases):
    1. Let k be the greatest common factor of x and y.
    2. If x and y share a common factor k, where k is greater than 1, then recursively call this algorithm to find the scale for (x/k)L (y/k)s; the final scale will be (x/k)L (y/k)s duplicated k times.
    3. If x and y don't share a common factor that is greater than 1 (if x and y are coprime), then:
      1. Let m1 = min(x, y) and m2 = max(x, y).
      2. Let z = m2 mod m1 and w = m1 - z.
      3. Let prescale be the mos string for zL ws. Recursively call this algorithm to find the scale for zL ws; the final scale will be based on this.
      4. If x > y, reverse the order of characters in the prescale. This is only needed if there are more L's than s's in the final scale.
      5. To produce the final scale, the L's and s's of the prescale must be replaced with substrings consisting of L's and s's. Let u = ceil(m2/m1) and v = floor(m2/m1).
        1. If x > y, every instance of an L in the prescale is replaced with one L and u s's, and every s replaced with one L and v s's. This produces the final scale in its brightest mode.
        2. If y > x, every instance of an L in the prescale is replaced with u L's and one s, and every s replaced with v L's and one s. This produces the final scale in its brightest mode.

Pseudocode

This is the pseudocode for the algorithm described above. (work-in-progress)

Pseudocode

ProduceMaximallyEvenScale(integer x : number of large steps, integer y : number of small steps) returns string : string encodes a MOS/MV2 scale represented in its brightest mode {

	string final_scale = ""
	
	// This is a separate function that returns the greatest common factor between x and y
	// This should return 1 if x and y are coprime
	integer common_factor = FindLargestCommonFactor(x, y)

	// x and y have a common factor greater than 1, so it's a multi-period scale
	if (common_factor > 1) {
		string intermediate_scale = ProduceMaximallyEvenScale(x/common_factor, y/common_factor)
		for (integer i = 0 to common_factor) {
			final_scale += intermediate_scale
		}
	}

	// Both x and y are equal to 1
	else if (x == 1 AND y == 1) {
		final_scale = "Ls"
	}
	
	// ONLY x is equal to 1
	else if (x == 1 AND y != 1) {
		final_scale += "L"
		for (integer i = 0 to y) {
			final_scale += "s"
		}
	}

	// ONLY y is equal to 1
	else if (x != 1 AND y == 1) {
		for (integer i = 0 to x) {
			final_scale += "L"
		}
		final_scale += "s"
	}

	// Neither x nor y are equal to 1
	else if (x != 1 AND y != 1) {

		// There are more large steps than small steps
		if (x > y) {
			integer large_group_count = x % y
			integer small_group_count = y - large_group_count
			string large_group_production_rule = ""
			string small_group_production_rule = ""
	
			integer l_count = floor(x/y)
			for (integer i = 0 to l_count) {
				large_group_production_rule += "L"
				small_group_production_rule += "L"
			}
			large_group_production_rule += "Ls"
			small_group_production_rule += "s"
	
			string intermediate_scale = ProduceMaximallyEvenScale(large_group_count, small_group_count)
	
			for (integer i = 0 to intermediate_scale.length) {
				if (intermediate_scale[i] = "L") {
					final_scale += large_group_production_rule
				} else if (intermediate_scale[i] = "s") {
					final_scale += small_group_production_rule
				}
			}
		} 
	
		// There are more small steps than large steps
		if (y > x) {
			integer large_group_count = y % x
			integer small_group_count = y - large_group_count
			string large_group_production_rule = ""
			string small_group_production rule = ""
	
			integer l_count = floor(y/x)
			for (integer i = 0 to l_count) {
				large_group_production_rule += "s"
				small_group_production_rule += "s"
			}
			large_group_production_rule += "sL"
			small_group_production_rule += "L"
	
			string intermediate_scale = ProduceMaximallyEvenScale(large_group_count, small_group_count)
	
			for (integer i = 0 to intermediate_scale.length) {
				if (intermediate_scale[i] = "L") {
					final_scale += large_group_production_rule
				} else if (intermediate_scale[i] = "s") {
					final_scale += small_group_production_rule
				}
			}
		}
	}

	return final_scale
}

Example

We take 5L7s, which will have 7 chunks

The chunks must partition the 5 "L"s, and 5 = 1 + 1 + 1 + 1 + 1 + 0 + 0.

So we get 5L2s, which we know is LLLsLLs and turns back to sL sL sL s sL sL s.

Finding a generator

The recursive structure also allows a recursive algorithm to find the generator:

To find the generator you reduce to a simple pattern you know the generator of, then plug everything back in.

If you do that to 5L 7s you get 5L 2s: LLLsLLs. You know that the generator of 5L 2s is LLLs, so using the above procedure for finding the pattern, the generator of 5L 7s is LsLsLss. If you don't know anything you just reduce all the way to 1L 1s and plug everything back in.

The reason why this works is that the reduction both preserves and reflects the generator; see the proofs section.

Tree of MOS patterns

MOS patterns have parents and children. If 1L 1s is the root of the tree, with any generator between 0\1 (for paucitonic 1L 1s) and 1\2 (for equalized 1L 1s) Every node aL bs has two children, aL (a+b)s and (a+b)L as (these MOS patterns are sister MOS patterns; they are called such because they have the same parent). The generator range of aL bs splits at the mediant of the endpoints of the parent interval (which is the generator size for basic aL bs), giving the generator ranges of the two child patterns.

The tree of MOS patterns starts with:

1L 1s
1L 2s        2L 1s
1L 3s 3L 1s  3L 2s 2L 3s

The corresponding tree of generator ranges looks like:

(0\1, 1\2)
(0\1, 1\3)            (1\3, 1\2)
(0\1, 1\4) (1\4, 1\3) (1\3, 2\5) (2\5, 1\2)

Proofs

Preservation of the MOS property

(Assume that the mos has length n; the notation w(X, Y) for a word w(L, s) in L, s means w with step sizes X substituted for L and Y substituted for s.)

Suppose we had three chunks L...s with r, r+1 and r+2 'L's. Then we have a length r+2 subword that's only 'L's, one that has one s at the end and one that has two 's's on either side, which means that the original scale was not MOS. Therefore the reduced word has two step sizes.

Without loss of generality assume r ≥ 1 (otherwise flip the roles of L and s). Let W'(λ, σ) be the reduced word with step sizes λ (for the larger chunk) and σ (for the smaller chunk), and assume that W' is not a mos. Then for some k, W' must have k-steps of the following sizes:

  1. p₁ λ's and q₁ σ's, represented by subword W₁(λ, σ) in W', corresponding to an interval in the mos with (p₁(r + 1) + q₁r) L's and k s's
  2. p₂ λ's and q₂ σ's, represented by subword W₂(λ, σ) in W', corresponding to an interval in the mos with (p₂(r + 1) + q₂r) L's and k s's. By slinking W₂ to the right until it begins in λ, which will never decrease the number of λ's, we can assume W₂ begins in λ.

Here, pᵢ + qᵢ = k and p₂ - p₁ ≥ 2.

Let K = p₁(r + 1) + q₁r + k. Then we have at least 3 different sizes for (K+1)-steps:

  1. w₁(L, s) = the word sW₁(Lr+1s, Lrs) [W₁ interpreted as a subword of the original mos], with (k + 1) s's
  2. w₂(L, s) = the first K+1 letters of W₂(Lr+1s, Lrs)
  3. w₃(L, s) = the last K+1 letters of W₂(Lr+1s, Lrs)

If w₂ contains fewer complete chunks (L...Ls) or at least 2 more than w₃, we are done, since they must automatically have different numbers of s's.

If w₂ and w₃ (which have the same length) contain the same number of complete chunks, one case is (X denotes a chunk boundary, < > are chunk boundaries that are also the boundary of the word, [] are non-chunk-boundary word boundaries.)

Case 1.1:

w2: <L ... sXL ... sXL ... sXL ... sXL ...]
w3:         <L ... sXL ... sXL ... sXL ... s>

This implies that the last chunk is bigger than the first one, a contradiction because w₂ begins in λ.

Case 1.2:

w1:  s[something with k s's]
w2: <L ... sXL ... sXL ... sXL ... s>
w3:         <L ... sXL ... sXL ... sXL ... s>

Truncate the strings as follows:

w1':  L ... [lop off the s at the beginning of w1, so we have k s's]
w2': <L ... sXL ... sXL ... sXL ... ] [lop off one s at the end of w2, so one fewer s than w3]
w3':         <L ... sXL ... sXL ... sXL ... s> [lop off an L at the beginning of w3, result has at most k-1 s's]

so this contradicts our original scale being a mos.

So we must have

Case 1.3:

w2: <L ... sXL ... sXL ... sXL ... sXL ...]
w3:   [... sXL ... sXL ... sXL ... sXL ... s>

or

Case 1.4:

w2: <L ... sXL ... sXL ... sXL ... sX]
w3:   [... sXL ... sXL ... sXL ... sXL ... s>

(both 1.3 and 1.4 imply w₃ has one more s).

If w₂ has one more complete chunk than w₃:

Case 2.1:

w2: <L ... sXL ... sXL ... sXL ... sXL ... s>
w3:                 <L ... sXL ... sXL ... sXL ... s>

⇒ w₂ has more s's.

Case 2.2:

w2: <L ... sXL ... sXL ... sXL ... sXL ... s>
w3:               [sXL ... sXL ... sXL ... sXL ... s>

⇒ do the same trick as in Case 1.2

Case 2.3:

w2: <L ... sXL ... sXL ... sXL ... sXL ... sXL ...]
w3:          [ ... sXL ... sXL ... sXL ... sXL ... s>

Case 2.4:

w2: <L ... sXL ... sXL ... sXL ... sXL ... sXL ...]
w3:                 <L ... sXL ... sXL ... sXL ... s>

Both 2.3 and 2.4 are contradictions since the first chunk is λ so has to be at least as big as the last one.

Preservation of generators

Assume there are more L's and s's, and that there is more than one s, and thus more than one chunk. Assume there is a generator. Assume the imperfect generator is bigger than the perfect generator. (If this isn't true, just use the inverted generator.) Because there are at least two chunk boundaries, and only one imperfect generator, there must be a chunk boundary with a perfect generator on top (the chunk boundary is on the left of the generator, e.g. ...|Ls|LLs|Ls...). Because there's a chunk boundary to the left, there's an s just to the left of the left endpoint of the generator. If the rightmost step of this generator were an L, scooting the generator one step to the left would make it smaller, which contradicts the assumption that the imperfect generator is larger than perfect. Thus, the rightmost step of this generator is an s. That means the right endpoint of this generator falls on a chunk boundary. We already know the left endpoint also falls on a chunk boundary, so this perfect generator is still present as an interval in the reduced MOS.

This interval is, in fact, the generator of the reduced scale. Indeed, you can build this generator on all of the chunk boundaries of the non-reduced scale. All but one of these will be perfect. The perfect ones will have their right endpoint be a chunk boundary, as we showed before, so this is an interval that's on all but one tone of the reduced scale. This is a generator.

Reflection of generators

Suppose there is a generator after chunking. Assume also that there are more L's than s's, and that the imperfect generator is larger than the perfect generator. This means that this interval, built on the chunk boundaries after expanding, will still be "a generator" on the chunk boundaries: it will be the same size on all but one of the chunk boundaries. Take one of the "perfect" (smaller) intervals. We showed previously that, before expansion, the step to its right was an L, just like its first step; therefore we can scoot it over for the entirety of the first chunk and keep it perfect. We now come to another chunk. If a "perfect" interval can be built on it then we can repeat. If the interval is imperfect, then we know that the step to its right is an s, which will make it smaller and thus perfect, and we can keep doing this for the remainder of the chunk. Therefore, the interval is a generator after expansion as well, since it is only imperfect in one position.

Uniqueness and existence of the generator

Every MOS can be reduced to nL 1s (or 1L ns). Each step of the reduction decreases either the number of L's or the number of s's (or both), so one of them must reach 1 at some point. (note that reducing further gets us to 1L 0s, which has a period, but no generator per se)

It is clear that the MOS nL 1s has a unique generator, L (or its inversion). However, the previous proof showed that reduction reflects generators, and so by induction all MOS scales have a single generator.

Child MOSes exist

Todo: expand

Going from a MOS scale aL bs and applying rules L → Ls, s → s or L → L, s → Ls, we end up with the child scales aL (a+b)s or (a+b)L bs. The layout of these scales is such that the stepwise algorithm immediately says these two are MOS too: in both cases, first we either exactly de-apply the rules given here, and end up with the parent scale which was chosen to be a MOS, or we get to an L↔s reversed scale with b L’s and a s’s which should end up being MOS too, for some clear reason not stated here right now yet.

See also