|
|
| Line 1,147: |
Line 1,147: |
| {{-44,-30},{0,19},{19,0}} | | {{-44,-30},{0,19},{19,0}} |
| |} | | |} |
|
| |
| == multimaps & multicommas ==
| |
|
| |
| If you spend much time exploring information about RTT online, it won’t be long until you come across “wedgies”, which are an alternative way to represent temperaments. You may not need them to do RTT stuff; a lot of the information you can get from them can be gotten otherwise from the already-discussed matrices. But you may find they appeal to you. This section covers those.
| |
|
| |
| === multimaps ===
| |
|
| |
| The mathematical structure used to represent a wedgie is called a '''multicovector''', and this structure is indeed related to the mathematical structure called the “covector”:
| |
|
| |
| * They both represent information written horizontally, as a row.
| |
| * They both use left angle brackets on the left and square brackets on the right, {{map|}}, to enclose their contents.
| |
| * They both exist on the left half of tuning duality, on the side built up out of ETs which concerns rank (not the side built up out of commas, which uses vectors/columns, and concerns nullity).
| |
|
| |
| The main difference between the two is superficial, and has to do with the “multi” part of the name. A plain covector comes in only one type, but a multicovector can be a bicovector, tricovector, quadricovector, etc. Yes, a multicovector can even be a plain covector, which can be called a monocovector when there might otherwise be ambiguity. Depending on its numeric prefix, a multicovector will be written with a different count of brackets on either side. For example, a bicovector uses two of each: {{multicovector|}}. A tricovector uses three of each: {{multicovector|rank=3|}}. And of course a (mono)covector is written with one of each, like {{map|}}.
| |
|
| |
| In order to make these materials as accessible as possible, I have been doing what I can to lean away from RTT jargon and instead toward generic, previously established mathematical and/or musical concepts. That is why I have avoided the terms "monzo", "val", "breed", and why I will now avoid "wedgie". When established mathematical and/or musical concepts are unavailable, we can at least use unmistakable analogs built upon what we do have. In this case, if in RTT we use covectors to represent maps, then analogously, we can refer to the thing multicovectors represent in RTT as a '''multimap'''.
| |
|
| |
| So we mentioned that a multimap is an alternative way to represent a temperament. Let's look at an example now. Meantone's multimap looks like this: {{multicovector|1 4 4}}. As you can see, it is a bicovector, or bimap, because it has two of each bracket.
| |
|
| |
| Why care about multimaps? Well, a key reason is that they can serve the same purpose as the canonical form of a temperament’s mapping-row-basis: the process for converting a mapping-row-basis to a multimap will convert any equivalent mapping-row-basis to the same exact multimap. In other words, a multimap can serve as a unique identifier for its temperament.
| |
|
| |
| Alright, then, sounds great! But how do I convert a mapping-row-basis to a multimap? The process is doable. It’s closely related to the wedge product<ref>The wedge product is also known as the exterior product. Exterior and interior products (∧ and ⨼) should not be confused with outer and inner products, which in RTT are ordinary matrix products between a vector and a covector. The outer product gives a matrix and the inner product a scalar. e.g. [1 2⟩⟨3 4] = ⟨[3 4⟩ [6 8⟩] and ⟨3 4][1 2⟩ = 11. In our application, the inner product is the same as the dot product used for maps and intervals.</ref> (hence the name “wedgie”), which we write it with the symbol ∧.
| |
|
| |
| First I’ll list the steps. Don’t worry if it doesn’t all make sense the first time. We’ll work through an example and go into more detail as we do. To be clear, what we're doing here is different from the strict definition of the wedge product as you may see it elsewhere; I'm specifically here describing the process for finding the multimap in the form you're going to be interested in for RTT purposes.
| |
|
| |
| # Take each combination of <span><math>r</math></span> primes where <span><math>r</math></span> is the rank, sorted in [https://en.wikipedia.org/wiki/Lexicographic_order lexicographic order], e.g. if we're in the 7-limit, we'd have <span><math>(2,3,5)</math></span>, <span><math>(2,3,7)</math></span>, <span><math>(2,5,7)</math></span>, and <span><math>(3,5,7)</math></span>.
| |
| # Convert each of those combinations to a square <span><math>r×r</math></span> matrix by slicing a column for each prime out of the mapping-row-basis and putting them together.
| |
| # Take each matrix's determinant.
| |
| # Set the results inside <span><math>r</math></span> brackets.
| |
|
| |
| And you've got your multimap!
| |
|
| |
| Another way to think about this is that you've found all of the '''[https://en.wikipedia.org/wiki/Minor_(linear_algebra) minors]''' (short for “minor determinants”) of the matrix, where a minor is the determinant of a square submatrix. So we can think of multimaps as lists of minors<ref>This operation is called the wedge product. Another way to think of it is as the difference between two outer products. For example, consider wedging {{map|7 11 16}} with {{map|12 19 28}}. Call these u and v, respectively. So u∧v (that's the wedge product) is the same thing as u.v - v.u (where the dots are outer products). Those two outer products are:<br>
| |
| <br>
| |
| {{vector|{{covector|84 133 196}} {{covector|132 209 308}} {{covector|192 304 448}}}}<br>
| |
| {{vector|{{covector|84 132 192}} {{covector|133 209 304}} {{covector|196 308 448}}}}<br>
| |
| <br>
| |
| And so it's clear to see that the difference is<br>
| |
| <br>
| |
| {{vector|{{covector|0 1 4}} {{covector|-1 0 4}} {{covector|-4 -4 0}}}}<br>
| |
| <br>
| |
| So it's really just a different way of slicing and dicing a bunch of determinants. With this difference of outer products approach, you do all the multiplications at once as the first step, then all of the differences at once as the second step. Whereas with the minors approach, you do a ton of separate differences of products individually.</ref>.
| |
|
| |
| Now, if you want the canonical multimap, two further steps are required:
| |
|
| |
| # Change the sign of every result if the first non-zero result is negative.
| |
| # Extract the GCD from these results.
| |
|
| |
| Let’s work through these steps for the example of meantone.
| |
|
| |
| We have rank <span><math>r</math></span> = 2, so we’re looking for every combination of two primes. That’s out of the three total primes we have in the 5-limit: 2, 3, and 5. So those combinations are <span><math>(2,3)</math></span>, <span><math>(2,5)</math></span>, and <span><math>(3,5)</math></span>. Those are already in lexicographic order, or in other words, just like how alphabetic order works, but generalized to work for size of numbers too (so that 11 comes after 2, not before).
| |
|
| |
| Here's the meantone mapping-row-basis again, with some color applied which should help identify the combinations:
| |
|
| |
| <math>
| |
| \begin{bmatrix}
| |
| \color{red}1 & \color{lime}0 & \color{blue}-4 \\
| |
| \color{red}0 & \color{lime}1 & \color{blue}4 \\
| |
| \end{bmatrix}
| |
| </math>
| |
|
| |
| So now each of those combinations becomes a square matrix, made out of bits from the mapping-row-basis, which again is:
| |
|
| |
| <math>
| |
| \begin{array}{ccc}
| |
| \text{(2,3)} & \text{(2,5)} & \text{(3,5)} \\
| |
| \begin{bmatrix}\color{red}1 & \color{lime}0 \\ \color{red}0 & \color{lime}1 \end{bmatrix} & \begin{bmatrix}\color{red}1 & \color{blue}-4 \\ \color{red}0 & \color{blue}4 \end{bmatrix} & \begin{bmatrix}\color{lime}0 & \color{blue}-4 \\ \color{lime}1 & \color{blue}4 \end{bmatrix}
| |
| \end{array}
| |
| </math>
| |
|
| |
| Now we must take each matrix’s determinant. For 2×2 matrices, this is quite straightforward.
| |
|
| |
| <math>
| |
| \begin{bmatrix}
| |
| a & b \\
| |
| c & d
| |
| \end{bmatrix}
| |
| →
| |
| ad - bc
| |
| </math>
| |
|
| |
| So the three determinants are
| |
|
| |
| <math>
| |
| (1 × 1) - (0 × 0) = 1 - 0 = 1 \\
| |
| (1 × 4) - (-4 × 0) = 4 - 0 = 4 \\
| |
| (0 × 4) - (-4 × 1) = 0 + 4 = 4
| |
| </math>
| |
|
| |
| So just set these inside a number brackets equal to the rank, and we’ve got {{multicovector|1 4 4}}.
| |
|
| |
| Wolfram Language doesn't have a built in way to show the proper count of brackets, but its Minors function can at least calculate the list of minors for you. The only trick is that you have to tell it the rank of your matrix as the second argument:
| |
|
| |
| {| class="wikitable"
| |
| !input
| |
| !output
| |
| |-
| |
| |<code>wedge[m_] := Minors[m, Length[m]]</code>
| |
|
| |
| <code>wedge[{{1,0,-4},{0,1,4}}]</code>
| |
| |<nowiki>{1, 4, 4}</nowiki>
| |
| |}
| |
|
| |
| Let's go for the canonical multimap. The first term is positive, so no sign changes are necessary. And these have no GCD, or in other words, their GCD is 1. So we're already there.
| |
|
| |
| This method even works on an equal temperament, e.g. {{map|12 19 28}}. The rank is 1 so each combination of primes has only a single prime: they’re <span><math>(2)</math></span>, <span><math>(3)</math></span>, and <span><math>(5)</math></span>. The square matrices are therefore <span><math>\begin{bmatrix}12\end{bmatrix} \begin{bmatrix}19\end{bmatrix} \begin{bmatrix}28\end{bmatrix}</math></span>. The determinant of a 1×1 matrix is defined as the value of its single term, so now we have 12 19 28. <span><math>r</math></span> = 1, so we set the answer inside one layer of brackets, so our monocovector is {{map|12 19 28}}.
| |
|
| |
| {| class="wikitable"
| |
| !input
| |
| !output
| |
| |-
| |
| |<code>wedge[<nowiki>{{12,19,28}}</nowiki>]</code>
| |
| |<nowiki>{12, 19, 28}</nowiki>
| |
| |}
| |
|
| |
| Going for the canonical multimap, we check that the leading term is positive, and no GCD. Both yes. So, this looks the same as what we started with, which is fine.
| |
|
| |
| Let’s try a slightly harder example now: a rank-3 temperament, and in the 7-limit. There are four different ways to take 3 of 4 primes: <span><math>(2,3,5)</math></span>, <span><math>(2,3,7)</math></span>, <span><math>(2,5,7)</math></span>, and <span><math>(3,5,7)</math></span>.
| |
|
| |
| If the mapping-row-basis is
| |
|
| |
| <math>
| |
| \begin{bmatrix}
| |
| \color{red}1 & \color{lime}0 & \color{blue}1 & \color{magenta}4 \\
| |
| \color{red}0 & \color{lime}1 & \color{blue}1 & \color{magenta}-1 \\
| |
| \color{red}0 & \color{lime}0 & \color{blue}-2 & \color{magenta}3 \\
| |
| \end{bmatrix}
| |
| </math>
| |
|
| |
| then the combinations are
| |
|
| |
| <math>
| |
| \begin{array}{ccc}
| |
| \text{(2,3,5)} &
| |
| \text{(2,3,7)} &
| |
| \text{(2,5,7)} &
| |
| \text{(3,5,7)} \\
| |
|
| |
| \begin{bmatrix}\color{red}1 & \color{lime}0 & \color{blue}1 \\ \color{red}0 & \color{lime}1 & \color{blue}1 \\ \color{red}0 & \color{lime}0 & \color{blue}-2 \end{bmatrix} &
| |
| \begin{bmatrix}\color{red}1 & \color{lime}0 & \color{magenta}4 \\ \color{red}0 & \color{lime}1 & \color{magenta}-1 \\ \color{red}0 & \color{lime}0 & \color{magenta}3 \end{bmatrix} &
| |
| \begin{bmatrix}\color{red}1 & \color{blue}1 & \color{magenta}4 \\ \color{red}0 & \color{blue}1 & \color{magenta}-1 \\ \color{red}0 & \color{blue}-2 & \color{magenta}3 \end{bmatrix} &
| |
| \begin{bmatrix}\color{lime}0 & \color{blue}1 & \color{magenta}4 \\ \color{lime}1 & \color{blue}1 & \color{magenta}-1 \\ \color{lime}0 & \color{blue}-2 & \color{magenta}3 \end{bmatrix} \\
| |
| \end{array}
| |
| </math>
| |
|
| |
| The determinant of a 3×3 matrix is trickier, but also doable:
| |
|
| |
| <math>
| |
| \begin{bmatrix}
| |
| a & b & c \\
| |
| d & e & f \\
| |
| g & h & i \\
| |
| \end{bmatrix}
| |
| →
| |
| a(ei - fh) - b(di - fg) + c(dh -eg)
| |
| </math>
| |
|
| |
| In natural language, that’s each element of the first row times the determinant of the square matrix from the other two columns and the other two rows, summed but with an alternating pattern of negation beginning with positive. If you ever need to do determinants of matrices bigger than 3×3, see [https://www.mathsisfun.com/algebra/matrix-determinant.html this webpage]. Or, you can just use an online calculator.
| |
|
| |
| And so our results are <span><math>-2</math></span>, <span><math>3</math></span>, <span><math>1</math></span>, <span><math>-11</math></span>. Set these inside triply-nested brackets, because it’s a trimap for a rank-3 temperament, and we get {{multicovector|rank=3|-2 3 1 -11}}.
| |
|
| |
| {| class="wikitable"
| |
| !input
| |
| !output
| |
| |-
| |
| |<code>wedge[{{1,0,1,4},{0,1,1,-1},{0,0,-2,3}}]</code>
| |
| |<nowiki>{-2, 3, 1, -11}</nowiki>
| |
| |}
| |
|
| |
| Now for canonical form. We need the first term to be positive; this doesn’t make a difference in how things behave, but is done because it canonicalizes things (we could have found the result where the first term came out positive by simply changing the order of the rows of our mapping-row-basis, which doesn’t affect how it works as a mapping at all, or mean there's anything different about the temperament). And so we change the signs<ref>If it helps you, you could think of this sign-changing step as paired with the GCD extraction step, if you think of it like extracting a GCD of -1.</ref>, and our list ends up as <span><math>2</math></span>, <span><math>-3</math></span>, <span><math>-1</math></span>, <span><math>11</math></span>. There's no GCD to extract. So now we have {{multicovector|rank=3|2 -3 -1 11}}.
| |
|
| |
| As for getting from a multimap back to the mapping-row-basis, you can solve a system of equations for that. Though it’s not easy and there may not be a unique solution. And you probably will never find yourself with a multimap but without a corresponding mapping-row-basis anyway.
| |
|
| |
| === multicommas ===
| |
|
| |
| You may have noticed that the canonical multimap for meantone, {{multicovector|1 4 4}}, looks really similar to the meantone comma, {{vector|-4 4 -1}}. This is not a coincidence.
| |
|
| |
| To understand why, we have to cover a few key points:
| |
| # Just as a vector is the dual of a covector, we also have a '''multivector''' which is the dual of a multicovector. Analogously, we call the thing the multivector represents a '''multicomma'''.
| |
| # We can calculate a multicomma from a comma-basis much in the same way we can calculate a multimap from a mapping-row-basis
| |
| # We can convert between multimaps and multicommas using an operation called “taking '''[[the dual]]'''”<ref>This operation uses the same process as is used for finding the complement in exterior algebra, however, whereas exterior algebra does not convert between vectors and covectors (it can be used on either one, staying within that category), with RTT's dual you switch which type it is as the last step. More details can be found below. The dual we use in RTT is #2 in the table. It essentially combines elements from both #1 and #3.
| |
|
| |
| {| class="wikitable"
| |
| |+'''Table 6(footnote).''' Three similar duals
| |
| !#
| |
| !dual type
| |
| !notes
| |
| !variance changing
| |
| !using RTT's extended bra-ket notation to
| |
| !operator
| |
| !example
| |
| !alternate example 1
| |
| !alternate example 2
| |
| !alternate example 3
| |
| !example (ASCII only)
| |
| !alternate example (ASCII only)
| |
| !
| |
| |-
| |
| |1
| |
| |Grassman/EA/orthogonal complement
| |
| |also called "dual" within EA, but "complement" is preferred to avoid confusion with the variance-changing MLA dual
| |
| |no
| |
| |demonstrate agnosticism to and unchanging of variance
| |
| |negation, overbar, tilde
| |
| |¬{{vector|1 4 4}} = {{vector|4 -4 1}}
| |
| |{{vector|1̅ ̅4̅ ̅4̅⟩}} = {{vector|4 -4 1}}
| |
| |
| |
| |
| |
| |~[1 4 4> = [4 -4 1>
| |
| |
| |
| |-
| |
| |2
| |
| |MLA dual
| |
| |is in exterior algebra form: compresses the antisymmetric/skew-symmetric matrix/tensor into a list of minors; this operation is the dual that RTT uses
| |
| |yes
| |
| |distinguish covariance from contravariance
| |
| |diamond operator, sine wave operator, (postfix) degree symbol, tilde
| |
| |⋄{{multicovector|1 4 4}} = {{vector|4 -4 1}}
| |
| |{{multicovector|1 4 4}}° = {{vector|4 -4 1}}
| |
| |∿{{multicovector|1 4 4}} = {{vector|4 -4 1}}
| |
| |
| |
| |<><<1 4 4]] = [4 -4 1>
| |
| |~<<1 4 4]] = [4 -4 1>
| |
| |-
| |
| |3
| |
| |MLA complement
| |
| |is in tensor form: uses the full antisymmetric/skew-symmetric matrix/tensor itself; this operation is also known as the "Hodge dual", but "Hodge star" is preferred to avoid confusion with a variance-changing MLA dual
| |
| |no
| |
| |demonstrate agnosticism to and unchanging of variance
| |
| |Hodge star, asterisk operator
| |
| |⋆{{map|{{map|0 1 4}} {{map|-1 0 4}} {{map|-4 -1 0}}}} = {{map|4 -4 1}}
| |
| |⋆[[0 1 4] [-1 0 4] [-4 -1 0]]⁰₂ = [4 -4 1]⁰₁
| |
| |∗{{map|{{map|0 1 4}} {{map|-1 0 4}} {{map|-4 -1 0}}}} = {{map|4 -4 1}}
| |
| |∗[[0 1 4] [-1 0 4] [-4 -1 0]]⁰₂ = [4 -4 1]⁰₁
| |
| |*<<0 1 4] <-1 0 4] <-4 -1 0]] = ⟨4 -4 1]
| |
| |*[[0 1 4] [-1 0 4] [-4 -1 0]] type (0,2) = [4 -4 1] type (0,1))
| |
| |}
| |
|
| |
| </ref>, which basically involves reversing the order of terms and changing the signs of some of them.
| |
|
| |
| [[File:Algebra notation.png|300px|thumb|right|'''Figure 6a.''' RTT bracket notation comparison.]]
| |
|
| |
| To demonstrate these points, let’s first calculate the multicomma from a comma-basis, and then confirm it by calculating the same multicomma as the dual of its dual multimap.
| |
|
| |
| Here’s the comma-basis for meantone: {{map|{{vector|-4 4 -1}}}}. Calculating the multicomma is almost the same as calculating the multimap. The only difference is that as a preliminary step you must transpose<ref>Or do an anti-transpose sandwich, if you want to be consistent with other operations discussed here; either way will work here.</ref> the matrix, or in other words, exchange rows and columns. In our bracket notation, that just looks like replacing {{map|{{vector|-4 4 -1}}}} with {{vector|{{map|-4 4 -1}}}}. Now we can see that this is just like our ET map example from the previous section: basically an identity operation, breaking the thing up into three 1×1 matrices <span><math>\begin{bmatrix}-4\end{bmatrix} \begin{bmatrix}4\end{bmatrix} \begin{bmatrix}-1\end{bmatrix}</math></span> which are their own determinants and then nesting back inside one layer of brackets because nullity is 1. So we have {{vector|-4 4 -1}}.
| |
|
| |
| If we want the canonical multicomma, extracting any GCD is necessary. But unlike with the canonical multimap, we can't necessarily assume the leading term's sign will be positive. Since the canonical state is defined in terms of the canonical multimap, if we want to know the signs of the canonical multicomma, we'll have to find the canonical multimap. We can either separately find the canonical multimap, then take its dual, and that'd be our canonical multicomma. Or, we can take the dual of the multicomma we've found here, and if that has a negative leading term, then we just need to change the signs on both the multimap and the multicomma so they remain each other's duals but
| |
| the multimap's leading term is positive, thus canonicalizing them together.
| |
|
| |
| Now let’s see how to do the dual operation.
| |
|
| |
| If your temperament's dimensionality <span><math>d</math></span> is 6 or less (within the 13-limit), you can take advantage of this table I've prepared, and use this simplified method:
| |
|
| |
| # Find the correct cell in Figure 6b below using your temperament's <span><math>d</math></span> and <span><math>g</math></span>, which stands for '''grade'''. Grade is like rank or nullity, but it is generic; if you are taking the dual of a multimap, you would use rank as the grade, and if you are taking the dual of a multicomma, you would use nullity as the grade. This cell should contain the same number of symbols as there are terms of your multimap.
| |
| # Match up the terms of your multimap with these symbols. If the symbol is <span><math>+</math></span>, do nothing. If the symbol is <span><math>-</math></span>, change the sign (positive to negative, or negative to positive; you could think of it like multiplying by either +1 or -1).
| |
| # Reverse the order of the terms.
| |
| # Set the result in the proper count of brackets.
| |
|
| |
| [[File:Dual sign patterns robin.png|400px|thumb|right|'''Figure 6b.''' Dual sign-change patterns, by <span><math>d</math></span>, <span><math>r</math></span>, and <span><math>n</math></span>.]]
| |
|
| |
| So in this case:
| |
|
| |
| # We have <span><math>d=3</math></span>, <span><math>r=2</math></span>, so the correct cell contains the symbols <span><math>+-+</math></span>.
| |
| # Matching these symbols up with the terms of our multimap, we don't change the sign of 1, we do change the sign of 4 to -4, and we don't change the sign of the second 4.
| |
| # Now we reverse 1 -4 4 to 4 -4 1.
| |
| # Now we set the result in the proper count of brackets: {{vector|4 -4 1}}
| |
|
| |
| Ta-da! Both operations get us to the same result: {{vector|4 -4 1}}.
| |
|
| |
| What’s the proper count of brackets though? Well, the total count of brackets on the multicomma and multimap for a temperament must always sum to the dimensionality of the system from which you tempered. It’s the same thing as <span><math>d - n = r</math></span>, just phrased as <span><math>r + n = d</math></span>, and where <span><math>r</math></span> should be the bracket count for the multimap and <span><math>n</math></span> should be the bracket count for the multicomma. So with 5-limit meantone, with dimensionality 3, there should be 3 total pairs of brackets. If 2 are on the multimap, then only 1 are on the multicomma.
| |
|
| |
| === more on duals ===
| |
|
| |
| Note the Pascal’s triangle shape to the numbers in Figure 6b. Also note that the mirrored results within each dimensionality are reverses of each other. Sometimes that means they’re identical, like <span><math>+-+-+</math></span> and <span><math>+-+-+</math></span>; other times not, like <span><math>+-++-+-+-+</math></span> and <span><math>+-+-+-++-+</math></span>.
| |
|
| |
| An important observation to make about multicommas and multimaps is that — for a given temperament — they always have the same count of terms. This may surprise you, since the rank and nullity for a temperament are often different, and the length of the multimap comes from the rank while the length of the multicomma comes from the nullity. But there’s a simple explanation for this. In either case, the length is not directly equal to the rank or nullity, but to the dimensionality choose the rank or nullity. And there’s a pattern to combinations that can be visualized in the symmetry of rows of Pascal’s triangle: <span><math>{d \choose n}</math></span> is always equal to <span><math>{d \choose {d - n}}</math></span>, or in other words, <span><math>{d \choose n}</math></span> is always equal to <span><math>{d \choose r}</math></span>. Here are some examples:
| |
|
| |
| {| class="wikitable"
| |
| |+'''Table 6a.''' Multi(co)vector prime combinations (<math>r</math> can be swapped for <math>n</math>)
| |
| !<math>d</math>
| |
| !<math>r</math>
| |
| !<math>d - r</math>
| |
| !<math>{d \choose r}</math>
| |
| !<math>{d \choose {d - r}}</math>
| |
| !count
| |
| |-
| |
| |3
| |
| |2
| |
| |1
| |
| |<math>(2,3) (2,5) (3,5)</math>
| |
| |<math>(2) (3) (5)</math>
| |
| |3
| |
| |-
| |
| |4
| |
| |3
| |
| |1
| |
| |<math>(2,3,5) (2,3,7) (2,5,7) (3,5,7)</math>
| |
| |<math>(2) (3) (5) (7)</math>
| |
| |4
| |
| |-
| |
| |5
| |
| |3
| |
| |2
| |
| |<math>(2,3,5) (2,3,7) (2,3,11) (2,5,7) (2,5,11) (2,7,11) (3,5,7) (3,5,11) (3,7,11) (5,7,11)</math>
| |
| |<math>(2,3) (2,5) (2,7) (2,11) (3,5), (3,7) (3,11) (5,7) (5,11) (7,11)</math>
| |
| |10
| |
| |}
| |
|
| |
| Each set of one side corresponds to a set in the other side which has the exact opposite elements.
| |
|
| |
| Note that multicommas could just as well serve the purpose of a unique identifier for temperaments. There’s no particular reason to prefer the canonical multimap to the canonical multicomma. By convention, however, the canonical multimap is the one that’s used.
| |
|
| |
| If you need to do this process for a higher dimensionality than 6, then you'll need to understand how I found the symbols for each cell of Figure 6b. Here's how<ref>
| |
| You may wonder: but why are these sign patterns the way they are? Well, to deeply understand this, you'd probably have to hit some math books. I can shed a little more light on it, but it will still be fairly hand-wavy. The basic gist of it is this. The sets of prime numbers we've looked at, such as (2,3) or (3,5,11) are really like combinations of basis vectors, or in other words, atomic elements that are incomparable, in different terms, orthogonal, however you want to call it. In most exterior algebra texts, you'll see them in abstract, variable form, like this: e₁, e₂, e₃, etc. and for this demonstration it will be easier to use them that way, so that's what we'll do. To be clear, 2 is like e₁, 3 is like e₂, 5 is like e₃, etc. So as you've seen, when we take the dual, the resulting dual's terms correspond to the complementary set of these basis vectors; i.e. if there are 5 of them, the corresponding term in the dual for the term with basis vector combination e₁e₄ will be e₂e₃e₅. We can write this like:<br>
| |
| <br>
| |
| ∗(e₁∧e₄) = (e₂∧e₃∧e₅)<br>
| |
| <br>
| |
| Let's look at a simple case: dimensionality 3. Here's all such pairs of dual basis vector combinations:<br>
| |
| <br>
| |
| e₁ ↔ e₂e₃<br>
| |
| e₂ ↔ e₁e₃<br>
| |
| e₃ ↔ e₁e₂<br>
| |
| <br>
| |
| We can rewrite this like<br>
| |
| <br>
| |
| 1|23<br>
| |
| 2|13<br>
| |
| 3|12<br>
| |
| <br>
| |
| Now, for each line, we need to swap elements until they are in order. Note that this is the kind of swapping where you imagine the objects are in boxes and we pick up two and a time and swap which box they're in; not the kind of swapping where you slide them around a table to change order and afterwards shift things around to fill in gaps.<br>
| |
| <br>
| |
| 1|23 (already done)<br>
| |
| 2|13, 1|23 (done, 1 swap necessary)<br>
| |
| 3|12, 1|32, 1|23 (done, 2 swaps necessary)<br>
| |
| <br>
| |
| Finally, you count the number of swaps required to get things in order. If the count is odd, then this term will be negative in the dual. If it is positive, this term will be positive. This is the derivation of the sign change pattern for d=3 g=1 being +-+. But we still haven't really explained why this is. That's because a property of exterior algebra is that it's not exactly commutative. e₁e₂ ≠ e₂e₁. Instead, e₁e₂ = -e₂e₁! So every time you need to swap these elements, it introduces another sign change. let's try one more example: d=5 r=3.<br>
| |
| <br>
| |
| e₁e₂e₃ ↔ e₄e₅<br>
| |
| e₁e₂e₄ ↔ e₃e₅<br>
| |
| e₁e₂e₅ ↔ e₃e₄<br>
| |
| e₁e₃e₄ ↔ e₂e₅<br>
| |
| e₁e₃e₅ ↔ e₂e₄<br>
| |
| e₁e₄e₅ ↔ e₂e₃<br>
| |
| e₂e₃e₄ ↔ e₁e₅<br>
| |
| e₂e₃e₅ ↔ e₁e₄<br>
| |
| e₂e₄e₅ ↔ e₁e₃<br>
| |
| e₃e₄e₅ ↔ e₁e₂<br>
| |
| <br>
| |
| Rewrite it:<br>
| |
| <br>
| |
| 123|45<br>
| |
| 124|35<br>
| |
| 125|34<br>
| |
| 134|25<br>
| |
| 135|24<br>
| |
| 145|23<br>
| |
| 234|15<br>
| |
| 235|14<br>
| |
| 245|13<br>
| |
| 345|12<br>
| |
| <br>
| |
| Swap until in order:<br>
| |
| <br>
| |
| 123|45<br>
| |
| 124|35, 123|45<br>
| |
| 125|34, 123|54, 123|45<br>
| |
| 134|25, 124|35, 123|45<br>
| |
| 135|24, 125|34, 123|54, 123|45<br>
| |
| 145|23, 125|43, 123|45<br>
| |
| 234|15, 134|25, 124|35, 123|45<br>
| |
| 235|14, 135|24, 125|34, 123|54, 123|45<br>
| |
| 245|13, 145|23, 125|43, 123|45<br>
| |
| 345|12, 145|32, 125|34, 123|54, 123|45<br>
| |
| <br>
| |
| Counting swaps, we see 0,1,2,2,3,2,3,4,3,4 and that gives even,odd,even,even,odd,even,odd,even,odd,even, so that gives +-++-+-+-+. Great!
| |
| </ref>:
| |
|
| |
| # Take the rank, halved, rounded up. In our case, <span><math>\lceil \frac{r}{2} \rceil = \lceil \frac{2}{2} \rceil = \lceil 1 \rceil = 1</math></span>. Save that result for later. Let’s call it <span><math>x</math></span>.
| |
| # Find the lexicographic combinations of <span><math>r</math></span> primes again: <span><math>(2,3)</math></span>, <span><math>(2,5)</math></span>, <span><math>(3,5)</math></span>. Except this time we don’t want the primes themselves, but their indices in the list of primes. So: <span><math>(1,2)</math></span>, <span><math>(1,3)</math></span>, <span><math>(2,3)</math></span>.
| |
| # Take the sums of these sets of indices, and to each sum, also add <span><math>x</math></span>. So <span><math>1+2+x</math></span>, <span><math>1+3+x</math></span>, <span><math>2+3+x</math></span> = <span><math>1+2+1</math></span>, <span><math>1+3+1</math></span>, <span><math>2+3+1</math></span> = <span><math>4</math></span>, <span><math>5</math></span>, <span><math>6</math></span>.
| |
| # Even terms become <span><math>+</math></span>'s and odd terms become <span><math>-</math></span>'s.
| |
|
| |
| Alternatively, you can just use this Wolfram Language computational notebook, which can calculate duals for you. It's a little trickier than other Wolfram Language tools shared here. I've basically recreated the multi(co)vector form in Wolfram with a tuple type where the first element is your multi(co)vector as a list of its terms, and the second element is its grade and variance. Variance<ref>(Multi)covectors are covariant, while (multi)vectors are contravariant. This has to do with how vectors vary with respect to the system's units. Covectors vary in the same direction as the units, hence the co- prefix meaning "with", while (contra)vectors vary in the opposite direction to the units, hence the contra- prefix meaning "against".</ref> basically means which side of duality it is on. So variance is encoded via the sign of the grade, i.e. if this is a multivector, the grade is positive, and if it is a multicovector, then the grade is negative<ref>If the grade is zero, you probably don't need this tool, but it is capable of handling this case! When the grade is zero, it has no way to figure the dimensionality of the system (in other cases it calculates it based on the lenght of the multi(co)vector), so you must provide that yourself. So as a second argument, simply provide the grade and variance of the target dual. For example, if you have the multivector for JI (where nothing is tempered out), {{1}, 0}, there's no way to tell what prime limit you're in; so if you're in 5-limit, you would use dual[{{1}, 0}, -3], because you know the grade of the dual multicovector is 3 and it should be negative because multicovectors encode their variance as a negative sign on the grade here. One last point here: multi(co)vectors with grade 0 are neither covariant nor contravariant, in other words they are neither covectors nor vectors; they are simply scalars, and so you can actually call this like dual[{1, 0}, -3] if you prefer.</ref>. Again, grade is just generic rank or nullity, so it will simply be the count of brackets of your multi(co)vector.
| |
|
| |
| {| class="wikitable"
| |
| |+Wolfram Language code ([https://www.wolframcloud.com/obj/d66b5b53-e816-42bc-b93c-05a24cf05090 try it])
| |
| !input
| |
| !output
| |
| |-
| |
| |<code>multiIndices[d_,g_] := Subsets[Range[d],{g}]</code>
| |
|
| |
|
| |
| <code>inversePascal[length_, g_] := If[g==0,Error,First[Association[Solve[Binomial[d, g] == length && d >= 0, d, Integers]]]]</code>
| |
|
| |
|
| |
| <code>multiFormToTensorForm[{w_, d_, g_}] := SymmetrizedArray[MapThread[Rule[#1,#2]&,{multiIndices[d,g],w}],ConstantArray[d,g],Antisymmetric[All]]</code>
| |
|
| |
|
| |
| <code>tensorFormToMultiForm[{m_, d_, g_}]:= Module[{assoc},</code>
| |
|
| |
| <code> assoc = Association[SymmetrizedArrayRules[m]];</code>
| |
|
| |
| <code> Map[If[KeyExistsQ[assoc, #],assoc[#], 0]&,multiIndices[d,g]]</code>
| |
|
| |
| <code>]</code>
| |
|
| |
|
| |
| <code>multiDual[{w_, g_}, inputDualG_:0] :=Module[{d, absG, signG, absDualG, dualG, signTweak},</code>
| |
|
| |
| <code> absG = Abs[g];</code>
| |
|
| |
| <code> signG = Sign[g];</code>
| |
|
| |
| <code> d = inversePascal[Length[w], absG];</code>
| |
|
| |
| <code> absDualG = d - absG;</code>
| |
|
| |
| <code> dualG = If[g==0,inputDualG,-signG*absDualG];</code>
| |
|
| |
| <code> signTweak = If[signG==1&&Mod[absG(d-absG),2]==1,-1,1];</code>
| |
|
| |
| <code> If[g==0,{w,dualG},{signTweak*tensorFormToMultiForm[{HodgeDual[multiFormToTensorForm[{w,d,absG}]],d,absDualG}], dualG}]</code>
| |
|
| |
| <code>]</code>
| |
|
| |
|
| |
| <code>multiDual[{{107,-87,72,-49,31},4}]</code>
| |
|
| |
| <code>multiDual[{{31,49,72,87,107},-1}]</code>
| |
| |{{31,49,72,87,107},-1}
| |
| {{107,-87,72,-49,31},4}
| |
| |}
| |
|
| |
| === tempered lattice fractions generated by prime combinations ===
| |
|
| |
| So we now understand how to get to canonical multimaps. And we understand that they uniquely identify the temperament. But what about the individual terms — do they mean anything in and of themselves? It turns out: yes!
| |
|
| |
| The first thing to understand is that each term of the canonical multimap pertains to a different combination of primes. We already know this: it’s how we calculated it from the mapping-row-basis. For example, in the canonical multimap for meantone, {{multicovector|1 4 4}}, the 1 is for <span><math>(2,3)</math></span>, the first 4 is for <span><math>(2,5)</math></span>, and the second 4 is for <span><math>(3,5)</math></span>.
| |
|
| |
| Now, let’s convert every term of the canonical multimap by taking its absolute value and its inverse. In this case, each of our terms is already positive, so that has no effect. But taking the inverse converts us to <span><math>\frac 11</math></span>, <span><math>\frac 14</math></span>, <span><math>\frac 14</math></span>. These values tell us what fraction of the tempered lattice we can generate using the corresponding combination of primes.
| |
|
| |
| What does that mean? Who cares? The motivation here is that it’s a good thing to be able to generate the entire lattice. We may be looking for JI intervals we could use as generators for our temperament, and if so, we need to know what primes to build them out of so that we can make full use of the temperament. So this tells us that if we try to build generators out of primes 2 and 3, we will succeed in generating <span><math>\frac 11</math></span> or in other words all of the tempered lattice. Whereas if we try to build the generators out of primes 2 and 5, or 3 and 5, we will fail; we will only be able to generate <span><math>\frac 14</math></span> of the lattice. In other words, prime 5 is the bad seed here; it messes things up.
| |
|
| |
| [[File:Generating lattice (2) (2).png|thumb|left|400px|'''Figure 6b.''' Visualization of how primes 2 and 3 are capable of generating the entire tempered lattice for meantone, whether as generators 2/1 and 3/1, or 2/1 and 3/2]]
| |
|
| |
| It’s easy to see why this is the case if you know how to visualize it on the tempered lattice. Let’s start with the happy case: primes 2 and 3. Prime 2 lets us move one step up (or down). Prime 3 lets us move one step right (or left). Clearly, with these two primes, we’d be able to reach any node in the lattice. We could do it with generators 2/1 and 3/1, in the most straightforward case. But we can also do it with 2/1 and 3/2: that just means one generator moves us down and to the right (or the opposite), and the other moves us straight up by one (or the opposite) ''(see Figure 6b)''. 2/1 and 4/3 works too: one moves us to the left and up two (or… you get the idea) and the other moves us straight up by one. Heck, even 3/2 and 4/3 work; try it yourself.
| |
|
| |
| [[File:Generating lattice (2) (1).png|thumb|right|400px|'''Figure 6c.''' Visualization of how neither primes 2 and 5 or 3 and 5 are capable of generating the entire tempered lattice for meantone; they can only generate <span><math>\frac 14</math></span>th of it]]
| |
|
| |
| But now try it with only 5 and one other of primes 2 or 3. Prime 5 takes you over 4 in both directions. But if you have only prime 2 otherwise, then you can only move up or down from there, so you’ll only cover every fourth vertical line through the tempered lattice. Or if you only had prime 3 otherwise, then you could only move left and right from there, you’d only cover every fourth horizontal line ''(see Figure 6c)''.
| |
|
| |
| One day you might come across a canonical multimap which has a term equal to zero. If you tried to interpret this term using the information here so far, you'd think it must generate <span><math>\frac 10</math></span>th of the tempered lattice. That's not easy to visualize or reason about. Does that mean it generates essentially infinity lattices? No, not really. More like the opposite. The question itself is somewhat undefined here. If anything, it's more like that combination of primes generates approximately ''none'' of the lattice. Because in this situation, the combination of primes whose canonical multimap term is zero generates so little of the tempered lattice that it's completely missing one entire dimension of it, so it's an infinitesimal amount of it that it generates. For example, the 11-limit temperament 7&12&31 has canonical multimap {{map|rank=3|0 1 1 4 4 -8 4 4 -12 -16}} and mapping-row-basis {{vector|{{map|1 0 -4 0 -12}} {{map|0 1 4 0 8}} {{map|0 0 0 1 1}}}}; we can see from this how primes <span><math>(2,3,5)</math></span> can only generate a rank-2 cross-section of the full rank-3 lattice, because while 2 and 3 do the trick of generating that rank-2 part (exactly as they do in 5-limit meantone), prime 5 doesn't bring anything to the table here so that's all we get.
| |
|
| |
| We’ll look in more detail later at how exactly to best find these generators, once you know which primes to make them out of.
| |
|
| |
|
| == other topics (TBD) == | | == other topics (TBD) == |
|
| |
|
| === summary diagrams and tables === | | === tuning === |
| | |
| [[File:RTT clean 3.png|800px|center|thumb|'''Figure 7a.''' Diagram of core RTT concepts. Note the † on dual, null-space, wedge product, and canonical form operations, which asks you to sandwich the operation between anti-transposes when moving from the comma side of duality to the mapping-row side. In the case of the wedge product, the anti-transpose afterward has no meaning because it has become a list of minors. In the case of the dual, it has no meaning at all, because it already begins as a list of minors.]]
| |
| | |
| {| class="wikitable"
| |
| |+ '''Table 7a.''' RTT terminology
| |
| !terminology category
| |
| !building block →
| |
| ! colspan="4" |ways to identify a temperament
| |
| !← building block
| |
| |-
| |
| !RTT application
| |
| |map, mapping-row (often an ET)
| |
| |mapping, mapping-row-basis
| |
| |multimap
| |
| |multicomma
| |
| |comma-basis
| |
| |interval, comma
| |
| |-
| |
| !RTT structure
| |
| |map
| |
| |list of maps
| |
| |list of minors
| |
| |list of minors
| |
| |list of prime count lists
| |
| |prime count list
| |
| |-
| |
| !linear algebra structure
| |
| |row vector, matrix row
| |
| |matrix
| |
| |minors row vector
| |
| |minors (column) vector
| |
| |matrix
| |
| |(column) vector, matrix column
| |
| |-
| |
| !multilinear algebra structure<ref>RTT uses multilinear algebra structures, but does not use the conventional tensor (multi-dimensional array) representations of them; instead, it uses two copies of exterior algebra, one on each side of the duality, and an extended version of bra-ket notation. In other words, you can think of the multi(co)vectors used in RTT as compressed forms of antisymmetric tensors. A tensor is like a multi-dimensional array, or you could think of it as a generalization of matrices to other dimensions besides 2. And confusingly, antisymmetric doesn't mean the non-symmetric or undoing symmetry; it is a specific type of symmetry. This is made clearer in another name for antisymmetric, which is skew-symmetric. This reveals that the type of symmetry these tensors exhibit is along a skew, or diagonal. Let's take the example of meantone. Technically speaking, when you take the wedge product of two vectors (or covectors), the result is a matrix:
| |
|
| |
|
| <math>
| | === timbre === |
| \left[ \begin{array} {rrr}
| |
| 0 & 1 & 4 \\
| |
| -1 & 0 & 4 \\
| |
| -4 & -4 & 0 \\
| |
| \end{array} \right]
| |
| </math>
| |
| | |
| But this isn't a particularly efficient representation of this information. Everything in the bottom left triangular half is a mirror of what's in the top right triangular half, just with the signs changed! We compress this as {{multicovector|1 4 4}} instead, leveraging the antisymmetry. For a higher dimensional temperament, the tensor representation would be a higher-dimensional square, such as a cube, hypercube, 5-cube, etc. and the antisymmetry would lead to one tetrahedral, 4-simplex, 5-simplex, etc. half being mirrored but with signs changed. So we compress it into a multicovector with even more brackets. No big deal.
| |
| </ref>
| |
| |covector
| |
| |list of covectors
| |
| |multicovector
| |
| |multivector
| |
| |list of vectors
| |
| |vector
| |
| |-
| |
| !extended bra-ket notation representation
| |
| |bra
| |
| |ket of bras
| |
| |nested bras
| |
| |nested kets
| |
| |bra of kets
| |
| |ket
| |
| |-
| |
| !RTT jargon
| |
| |val
| |
| |list of vals
| |
| |wedgie, multival
| |
| |multimonzo
| |
| |list of monzos
| |
| |monzo
| |
| |}
| |
| | |
| === tuning === | |
|
| |
|
| === scales === | | === scales === |
| Line 1,681: |
Line 1,158: |
| === lattices === | | === lattices === |
|
| |
|
| === finding approximate JI generators === | | === notation === |
| | |
| === non-octave periods ===
| |
|
| |
|
| == outro == | | == outro == |