Douglas Blumeyer's RTT How-To: Difference between revisions

Line 488:

</math>

We call such a matrix a '''comma basis'''. The plural of “basis” is “bases”, but pronounced like BAY-sees (/ˈbeɪ siz/).

We call such a matrix a '''comma-basis'''. The plural of “basis” is “bases”, but pronounced like BAY-sees (/ˈbeɪ siz/).

Now how in the world could that matrix represent the same temperament as {{map|19 30 44}}? Well, they’re two different ways of describing it. {{map|19 30 44}}, as we know, tells us how many generator steps it takes to reach each prime approximation. This matrix, it turns out, is an equivalent way of stating the same information. This matrix is a minimal representation of the null-space of that mapping, or in other words, of all the commas it tempers out. (Don't worry about the word "mapping" just yet; for now, just imagine I'm writing "map". We'll explain the difference very soon.).

This was a bit tricky for me to get my head around, so let me hammer this point home: when you say "the null-space", you're referring to ''the entire infinite set of all commas that a mapping tempers out'', ''not only'' the two commas you see in any given basis for it. Think of the comma basis as one of many valid sets of instructions to find every possible comma, by adding or subtracting (integer multiples of) these two commas from each other<ref>To be clear, because what you are adding and subtracting in interval vectors are exponents (as you know), the commas are actually being multiplied by each other; e.g. {{vector|-4 4 -1}} + {{vector|10 1 -5}} = {{vector|6 5 -6}}, which is the same thing as <math>\frac{81}{80} × \frac{3072}{3125} = \frac{15552}{15625}</math></ref>. The math term for adding and subtracting vectors like this, which you will certainly see plenty of as you explore RTT, is "linear combination". It should be visually clear from the PTS diagram that this 19-ET comma basis couldn't be listing every single comma 19-ET tempers out, because we can see there are at least four temperament lines that pass through it (there are actually infinity of them!). But so it turns out that picking two commas is perfectly enough; every other comma that 19-ET tempers out could be expressed in terms of these two!

This was a bit tricky for me to get my head around, so let me hammer this point home: when you say "the null-space", you're referring to ''the entire infinite set of all commas that a mapping tempers out'', ''not only'' the two commas you see in any given basis for it. Think of the comma-basis as one of many valid sets of instructions to find every possible comma, by adding or subtracting (integer multiples of) these two commas from each other<ref>To be clear, because what you are adding and subtracting in interval vectors are exponents (as you know), the commas are actually being multiplied by each other; e.g. {{vector|-4 4 -1}} + {{vector|10 1 -5}} = {{vector|6 5 -6}}, which is the same thing as <math>\frac{81}{80} × \frac{3072}{3125} = \frac{15552}{15625}</math></ref>. The math term for adding and subtracting vectors like this, which you will certainly see plenty of as you explore RTT, is "linear combination". It should be visually clear from the PTS diagram that this 19-ET comma-basis couldn't be listing every single comma 19-ET tempers out, because we can see there are at least four temperament lines that pass through it (there are actually infinity of them!). But so it turns out that picking two commas is perfectly enough; every other comma that 19-ET tempers out could be expressed in terms of these two!

Try one. How about the hanson comma, {{vector|6 5 -6}}. Well that one’s too easy! Clearly if you go down by one magic comma to {{vector|10 1 -5}} and then up by one meantone comma you get one hanson comma. What you’re doing when you’re adding and subtracting multiples of commas from each other like this are technically called [https://en.wikipedia.org/wiki/Elementary_matrix|elementary column operations]. Feel free to work through any other examples yourself.

Line 504:

[[File:Different nestings.png|400px|thumb|left|'''Figure 5a.''' How to write matrices in terms of either columns/vectors/commas or rows/covectors/maps.]]

We can extend our angle bracket notation (technically called [https://en.wikipedia.org/wiki/Bra%E2%80%93ket_notation bra-ket notation, or Dirac notation]<ref>Bra-ket notation comes to RTT from quantum mechanics, not algebra.</ref>) to handle matrices by nesting rows inside columns, or columns inside rows ''(see Figure 5a)''. For example, we could have written our comma basis like this: {{map|{{vector|-4 4 -1}} {{vector|-10 -1 5}}}}. Starting from the outside, the {{map|}} tells us to think in terms of a row. It's just that this row isn't a row of numbers, like the ones we've gotten used to by now, but rather a row of ''columns of'' numbers. So this row houses two such columns. Alternatively, we could have written this same matrix like {{vector|{{map|-4 -10}} {{map|4 -1}} {{map|-1 5}}}}, but that would obscure the fact that it is the combination of two familiar commas (but that notation ''would'' be useful for expressing a matrix built out of multiple maps, as we will soon see).

We can extend our angle bracket notation (technically called [https://en.wikipedia.org/wiki/Bra%E2%80%93ket_notation bra-ket notation, or Dirac notation]<ref>Bra-ket notation comes to RTT from quantum mechanics, not algebra.</ref>) to handle matrices by nesting rows inside columns, or columns inside rows ''(see Figure 5a)''. For example, we could have written our comma-basis like this: {{map|{{vector|-4 4 -1}} {{vector|-10 -1 5}}}}. Starting from the outside, the {{map|}} tells us to think in terms of a row. It's just that this row isn't a row of numbers, like the ones we've gotten used to by now, but rather a row of ''columns of'' numbers. So this row houses two such columns. Alternatively, we could have written this same matrix like {{vector|{{map|-4 -10}} {{map|4 -1}} {{map|-1 5}}}}, but that would obscure the fact that it is the combination of two familiar commas (but that notation ''would'' be useful for expressing a matrix built out of multiple maps, as we will soon see).

Sometimes a comma basis may have only a single comma. That’s okay. A single vector can become a matrix. To disambiguate this situation, you could put the vector inside row brackets, like this: {{map|{{vector|-4 4 -1}}}}. Similarly, a single covector can become a matrix, by nesting inside column brackets, like this: {{vector|{{map|19 30 44}}}}.

Sometimes a comma-basis may have only a single comma. That’s okay. A single vector can become a matrix. To disambiguate this situation, you could put the vector inside row brackets, like this: {{map|{{vector|-4 4 -1}}}}. Similarly, a single covector can become a matrix, by nesting inside column brackets, like this: {{vector|{{map|19 30 44}}}}.

If a comma basis is the name for the matrix made out of commas, then we could say a “'''mapping'''” is the name for the matrix made out of maps. Why isn't this one a "basis", you ask? Well, it can be thought of as a basis too. It depends on the context. When you use the word "mapping" for it, you're treating it like a function, or a machine: it takes in intervals, and spits out new forms of intervals. That's how we've been using it here. But in other places, you may be thinking of this matrix as a basis for the infinite space of possible maps that could be combined to produce a matrix which works the same way as a given mapping, i.e. it tempers out the same commas. In these contexts, it might make more sense to call such a mapping matrix a "mapping-row basis".

If a comma-basis is the name for the matrix made out of commas, then we could say a “'''mapping'''” is the name for the matrix made out of maps. Why isn't this one a "basis", you ask? Well, it can be thought of as a basis too. It depends on the context. When you use the word "mapping" for it, you're treating it like a function, or a machine: it takes in intervals, and spits out new forms of intervals. That's how we've been using it here. But in other places, you may be thinking of this matrix as a basis for the infinite space of possible maps that could be combined to produce a matrix which works the same way as a given mapping, i.e. it tempers out the same commas. In these contexts, it might make more sense to call such a mapping matrix a "mapping-row basis".

And now you wonder why it's not just "map basis". Well, that's answerable too. It's because "map" is the analogous term to an "interval", but we're looking for the analogous term to a "comma". A comma is an interval which is tempered out. So we need a word that means a map which tempers out, and that term is "mapping-row".

So, yes, that's right: maps are similar to commas insofar as — once you have more than one of them in your matrix — the possibilities for individual members immediately go infinite. Technically speaking, though, while a comma basis is a basis of the null-space of the mapping, a mapping-row basis is a ''row''-basis of the ''row''-space of the mapping.

So, yes, that's right: maps are similar to commas insofar as — once you have more than one of them in your matrix — the possibilities for individual members immediately go infinite. Technically speaking, though, while a comma-basis is a basis of the null-space of the mapping, a mapping-row basis is a ''row''-basis of the ''row''-space of the mapping.

One last note back on the bracket notation before we proceed: you will regularly see matrices across the wiki that use only square brackets on the outside, e.g. [{{map|5 8 12}} {{map|7 11 16}}] or [{{vector|-4 4 -1}} {{vector|-10 -1 5}}]. That's fine because it's unambiguous; if you have a list of rows, it's fairly obvious you've arranged them vertically, and if you've got a list of columns, it's fairly obvious you've arranged them horizontally. I personally prefer the style of using angle brackets at both levels — for slightly more effort, it raises slightly less questions — but using only square brackets on the outside should not be said to be wrong<ref>Besides, in most contexts the null-space of a linear mapping is thought of as a list of vectors, rather than a matrix, but it’s generally more helpful for us here to think of it smooshed together as a matrix.</ref>.

Line 528:

Working this out by hand goes like this (it is a standard linear algebra operation, so if you're comfortable with it already, you can skip this and other similar parts of these materials).

So here's our starting point, the meantone|magic comma basis:

So here's our starting point, the meantone|magic comma-basis:

<math>

Line 624:

</math>

And ta-da! You’ve found a mapping from a comma basis, and it is {{vector|{{map|19 30 44}}}}. In other words, for this temperament, you have converted a basis for its null-space to a row-basis for its mapping row-space. Feel free to try this with any other combination of two commas tempered out by this mapping-row.

And ta-da! You’ve found a mapping from a comma-basis, and it is {{vector|{{map|19 30 44}}}}. In other words, for this temperament, you have converted a basis for its null-space to a row-basis for its mapping row-space. Feel free to try this with any other combination of two commas tempered out by this mapping-row.

So why the anti-transpose sandwich? What we (and everyone) want in a canonical mapping is to have a triangle of zeros in the bottom left corner. What we want in a comma basis is also to have a triangle of zeros in the bottom left corner. But the comma basis is on the other side of duality from the mapping, so it must be transposed before we can apply our nullSpaceBasis[] function to it, because that function is designed for mappings. But when we transpose the comma basis we end up with the triangle of zeros in the top right. If we take the null-space of that and then transpose it back again, we don't get our canonical form of the mapping, we get a mapping with a triangle of zeros in the top right. The way to fix this is to anti-transpose instead of transpose, before and after taking the null-space. Because when you anti-transpose the comma basis, you still turn columns into rows, but this time the triangle of zeros stays on the bottom left.

So why the anti-transpose sandwich? What we (and everyone) want in a canonical mapping is to have a triangle of zeros in the bottom left corner. What we want in a comma-basis is also to have a triangle of zeros in the bottom left corner. But the comma-basis is on the other side of duality from the mapping, so it must be transposed before we can apply our nullSpaceBasis[] function to it, because that function is designed for mappings. But when we transpose the comma-basis we end up with the triangle of zeros in the top right. If we take the null-space of that and then transpose it back again, we don't get our canonical form of the mapping, we get a mapping with a triangle of zeros in the top right. The way to fix this is to anti-transpose instead of transpose, before and after taking the null-space. Because when you anti-transpose the comma-basis, you still turn columns into rows, but this time the triangle of zeros stays on the bottom left.

Here's the Wolfram Language implementation:

Line 646:

Notice how when writing our comma basis in Wolfram Language, we have to write it differently than we probably would otherwise. Wolfram doesn't understand RTT's angle bracket syntax for indicating how a matrix is sliced and diced; it supports only one way of writing matrices: as lists within lists, where the outermost list is always assumed to be vertical. So if we have a comma basis with two commas, we can't just write one comma and then the other; we have to do one element from each comma in a group at a time. Also, note that our output is within two layers of curly brackets; this is because it's a matrix with one row, not a vector with one column. None of this is a huge deal or anything, but again, it may just take a little getting used to.

Notice how when writing our comma-basis in Wolfram Language, we have to write it differently than we probably would otherwise. Wolfram doesn't understand RTT's angle bracket syntax for indicating how a matrix is sliced and diced; it supports only one way of writing matrices: as lists within lists, where the outermost list is always assumed to be vertical. So if we have a comma-basis with two commas, we can't just write one comma and then the other; we have to do one element from each comma in a group at a time. Also, note that our output is within two layers of curly brackets; this is because it's a matrix with one row, not a vector with one column. None of this is a huge deal or anything, but again, it may just take a little getting used to.

Now the null-space function, to take you from {{vector|{{map|19 30 44}}}} back to the matrix, is pretty much the same thing, but simpler! No need to anti-transpose. Just start at the augmentation step:

Line 726:

=== the other side of duality ===

So we can now convert back and forth between a mapping-row basis and a comma basis. We could imagine drawing a diagram with a line of duality down the center, with a temperament's mapping-row basis on the left, and its comma basis on the right. Either side ultimately gives the same information, but sometimes you want to come at it in terms of the maps, and sometimes in terms of the commas.

So we can now convert back and forth between a mapping-row basis and a comma-basis. We could imagine drawing a diagram with a line of duality down the center, with a temperament's mapping-row basis on the left, and its comma-basis on the right. Either side ultimately gives the same information, but sometimes you want to come at it in terms of the maps, and sometimes in terms of the commas.

So far we've looked at how to meet comma vectors to form a comma basis. Next, let's look at the other side of duality, and see how to form a mapping-row basis out of joining maps. In many ways, the approaches are similar; the line of duality is a lot like a mirror in that way.

So far we've looked at how to meet comma vectors to form a comma-basis. Next, let's look at the other side of duality, and see how to form a mapping-row basis out of joining maps. In many ways, the approaches are similar; the line of duality is a lot like a mirror in that way.

When we join two maps, we put them together into a matrix, just like how we put two vectors together into a matrix. But again, where vectors are vertical columns, maps are horizontal rows. So when we combine {{map|5 8 12}} and {{map|7 11 16}}, we get a matrix that looks like

Line 1,000:

=== rank and nullity ===

Let’s review what we’ve seen so far. 5-limit JI is 3-dimensional. When we have a rank-3 temperament of 5-limit JI, 0 commas are tempered out. When we have a rank-2 temperament of 5-limit JI, 1 comma is tempered out. When we have a rank-1 temperament of 5-limit JI, 2 commas are tempered out.<ref>Probably, a rank-0 temperament of 5-limit JI would temper 3 commas out. All I can think a rank-0 temperament could be is a single pitch, or in other words, everything is tempered out. So perhaps in some theoretical sense, a comma basis in 5-limit made out of 3 vectors, thus a square 3×3 matrix, as long as none of the lines are parallel, should minimally represent every interval in the space.</ref>

Let’s review what we’ve seen so far. 5-limit JI is 3-dimensional. When we have a rank-3 temperament of 5-limit JI, 0 commas are tempered out. When we have a rank-2 temperament of 5-limit JI, 1 comma is tempered out. When we have a rank-1 temperament of 5-limit JI, 2 commas are tempered out.<ref>Probably, a rank-0 temperament of 5-limit JI would temper 3 commas out. All I can think a rank-0 temperament could be is a single pitch, or in other words, everything is tempered out. So perhaps in some theoretical sense, a comma-basis in 5-limit made out of 3 vectors, thus a square 3×3 matrix, as long as none of the lines are parallel, should minimally represent every interval in the space.</ref>

There’s a straightforward formula here: <math>d - n = r</math>, where <math>d</math> is dimensionality, <math>n</math> is nullity, and <math>r</math> is rank. We’ve seen every one of those words so far except '''nullity'''. [[Nullity]] simply means the count of commas tempered out, or in other words, the count of commas in a basis for the null-space ''(see Figure 5c)''.

Line 1,069:

Because we're starting in 4D here, if we temper out one comma, we still have a rank-3 temperament, with 3 independent generators. Temper out two commas, and we have a rank-2 temperament, with 2 generators (remember, one of them is the period, which is usually the octave). And we’d need to temper out 3 commas here to pinpoint a single ET.

The particular case I’d like to focus our attention on here is the rank-2 case. This is the first situation we’ve been able to achieve which boasts both an infinitude of matrices made from comma vectors which can represent the temperament by its comma basis, as well as an infinitude of matrices made from ET maps which can represent a temperament by its mapping-row basis. These are not contradictory. Let’s look at an example: septimal meantone.

The particular case I’d like to focus our attention on here is the rank-2 case. This is the first situation we’ve been able to achieve which boasts both an infinitude of matrices made from comma vectors which can represent the temperament by its comma-basis, as well as an infinitude of matrices made from ET maps which can represent a temperament by its mapping-row basis. These are not contradictory. Let’s look at an example: septimal meantone.

Septimal meantone may be thought of as the temperament which tempers out the meantone comma and the starling comma (126/125), or “meantone|starling”. But it may also be thought of as “meantone|marvel”, where the marvel comma is 225/224. We don’t even necessarily need the meantone comma at all: it can even be “starling|marvel”! This speaks to the fact that any temperament with a nullity greater than 1 has an infinitude of equivalent comma bases. It’s up to you which one to use.

Line 1,108:

maps the fourth (4/3, {{vector|2 -1 0 }}) to {{vector|0 1}}.

It’s often the case that a temperament’s nullity is greater than 1 or its rank is greater than 1, and therefore we have an infinitude of equivalent ways of expressing the comma basis or the mapping-row basis. This can be problematic, if we want to efficiently communicate about and catalog temperaments. It’s good to have a standardized form in these cases. The approach RTT takes here is to get these matrices into '''“canonical” form'''. In plain words, this just means: we have a function which takes in a matrix and spits out a matrix of the same shape, and no matter which matrix we input from a set of matrices which we consider all to be equivalent to each other, it will spit out the same result. This output is what we call the “canonical” matrix, and it can therefore uniquely identify a temperament.

It’s often the case that a temperament’s nullity is greater than 1 or its rank is greater than 1, and therefore we have an infinitude of equivalent ways of expressing the comma-basis or the mapping-row basis. This can be problematic, if we want to efficiently communicate about and catalog temperaments. It’s good to have a standardized form in these cases. The approach RTT takes here is to get these matrices into '''“canonical” form'''. In plain words, this just means: we have a function which takes in a matrix and spits out a matrix of the same shape, and no matter which matrix we input from a set of matrices which we consider all to be equivalent to each other, it will spit out the same result. This output is what we call the “canonical” matrix, and it can therefore uniquely identify a temperament.

To be clear, canonical form isn’t necessary to avoid ambiguity: you will never find a comma basis that could represent more than one temperament.

To be clear, canonical form isn’t necessary to avoid ambiguity: you will never find a comma-basis that could represent more than one temperament.

I've seen many specialized matrix forms used in RTT for problems like this, such as "[[IRREF|integer canonical form]]", [https://en.wikipedia.org/wiki/Hermite_normal_form Hermite Normal Form], and maybe others. What we will be using here is a form I’ve developed recently in collaboration with Dave Keenan that we’re calling [[TBD canonical form]].<ref>Historically, Hermite Normal Form was used as if it gave a unique identifier for each temperament, when in fact it did not. It failed to remove possibly-hidden common factors in the columns of comma bases and rows of mapping-row bases, leading to situations which were named "[[torsion]]" and "[[contorsion]]", respectively. Hermite Canonical Form goes too far; it reduces the matrix's diagonals to all 1's or 0's, which loses important information for temperaments with non-octave periods. Integer canonical form removes such common factors without compromising non-octave periods, therefore truly giving a unique identifier, and also eliminating the need to deal with enfactored mappings or comma-bases.</ref>.

Line 1,125:

If you take the integer canonical form of {{vector|{{map|5 8 12}} {{map|7 11 16}}}}, that’s what you get. It’s also what you get if you take the integer canonical form of {{vector|{{map|12 19 28}} {{map|19 30 44}}}}, etc. That’s the power of canonicalization.

To find the integer canonical form, we can combine the two processes we already know how to do: null-space for getting from a mapping-row basis to a comma basis, and anti-null-space to get from a comma basis to a mapping-row basis. Basically, to achieve canonical form of one type of basis, we convert it into the other type of basis, then back, and voilà: canonicalization.

To find the integer canonical form, we can combine the two processes we already know how to do: null-space for getting from a mapping-row basis to a comma-basis, and anti-null-space to get from a comma-basis to a mapping-row basis. Basically, to achieve canonical form of one type of basis, we convert it into the other type of basis, then back, and voilà: canonicalization.

For this, we need to up our game to Wolfram computable notebooks. You can click "Make Your Own Copy" in the top left of the screen if you want to modify this notebook to make your own calculations.

Line 1,328:

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 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.

Line 1,391:

[[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.

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 <math>\begin{bmatrix}-4\end{bmatrix} \begin{bmatrix}4\end{bmatrix} \begin{bmatrix}-1\end{bmatrix}</math> 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}}.

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 <math>\begin{bmatrix}-4\end{bmatrix} \begin{bmatrix}4\end{bmatrix} \begin{bmatrix}-1\end{bmatrix}</math> 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

Line 1,622:

|multimap

|multicomma

|comma basis

|comma-basis

|interval, comma

|-

@@ Line 488: / Line 488: @@
 </math>
-We call such a matrix a '''comma basis'''. The plural of “basis” is “bases”, but pronounced like BAY-sees (/ˈbeɪ siz/).
+We call such a matrix a '''comma-basis'''. The plural of “basis” is “bases”, but pronounced like BAY-sees (/ˈbeɪ siz/).
 Now how in the world could that matrix represent the same temperament as {{map|19 30 44}}? Well, they’re two different ways of describing it. {{map|19 30 44}}, as we know, tells us how many generator steps it takes to reach each prime approximation. This matrix, it turns out, is an equivalent way of stating the same information. This matrix is a minimal representation of the null-space of that mapping, or in other words, of all the commas it tempers out. (Don't worry about the word "mapping" just yet; for now, just imagine I'm writing "map". We'll explain the difference very soon.).
-This was a bit tricky for me to get my head around, so let me hammer this point home: when you say "the null-space", you're referring to ''the entire infinite set of all commas that a mapping tempers out'', ''not only'' the two commas you see in any given basis for it. Think of the comma basis as one of many valid sets of instructions to find every possible comma, by adding or subtracting (integer multiples of) these two commas from each other<ref>To be clear, because what you are adding and subtracting in interval vectors are exponents (as you know), the commas are actually being multiplied by each other; e.g. {{vector|-4 4 -1}} + {{vector|10 1 -5}} = {{vector|6 5 -6}}, which is the same thing as <span><math>\frac{81}{80} × \frac{3072}{3125} = \frac{15552}{15625}</math></span></ref>. The math term for adding and subtracting vectors like this, which you will certainly see plenty of as you explore RTT, is "linear combination". It should be visually clear from the PTS diagram that this 19-ET comma basis couldn't be listing every single comma 19-ET tempers out, because we can see there are at least four temperament lines that pass through it (there are actually infinity of them!). But so it turns out that picking two commas is perfectly enough; every other comma that 19-ET tempers out could be expressed in terms of these two!
+This was a bit tricky for me to get my head around, so let me hammer this point home: when you say "the null-space", you're referring to ''the entire infinite set of all commas that a mapping tempers out'', ''not only'' the two commas you see in any given basis for it. Think of the comma-basis as one of many valid sets of instructions to find every possible comma, by adding or subtracting (integer multiples of) these two commas from each other<ref>To be clear, because what you are adding and subtracting in interval vectors are exponents (as you know), the commas are actually being multiplied by each other; e.g. {{vector|-4 4 -1}} + {{vector|10 1 -5}} = {{vector|6 5 -6}}, which is the same thing as <span><math>\frac{81}{80} × \frac{3072}{3125} = \frac{15552}{15625}</math></span></ref>. The math term for adding and subtracting vectors like this, which you will certainly see plenty of as you explore RTT, is "linear combination". It should be visually clear from the PTS diagram that this 19-ET comma-basis couldn't be listing every single comma 19-ET tempers out, because we can see there are at least four temperament lines that pass through it (there are actually infinity of them!). But so it turns out that picking two commas is perfectly enough; every other comma that 19-ET tempers out could be expressed in terms of these two!
 Try one. How about the hanson comma, {{vector|6 5 -6}}. Well that one’s too easy! Clearly if you go down by one magic comma to {{vector|10 1 -5}} and then up by one meantone comma you get one hanson comma. What you’re doing when you’re adding and subtracting multiples of commas from each other like this are technically called [https://en.wikipedia.org/wiki/Elementary_matrix|elementary column operations]. Feel free to work through any other examples yourself.
@@ Line 504: / Line 504: @@
 [[File:Different nestings.png|400px|thumb|left|'''Figure 5a.''' How to write matrices in terms of either columns/vectors/commas or rows/covectors/maps.]]
-We can extend our angle bracket notation (technically called [https://en.wikipedia.org/wiki/Bra%E2%80%93ket_notation bra-ket notation, or Dirac notation]<ref>Bra-ket notation comes to RTT from quantum mechanics, not algebra.</ref>) to handle matrices by nesting rows inside columns, or columns inside rows ''(see Figure 5a)''. For example, we could have written our comma basis like this: {{map|{{vector|-4 4 -1}} {{vector|-10 -1 5}}}}. Starting from the outside, the {{map|}} tells us to think in terms of a row. It's just that this row isn't a row of numbers, like the ones we've gotten used to by now, but rather a row of ''columns of'' numbers. So this row houses two such columns. Alternatively, we could have written this same matrix like {{vector|{{map|-4 -10}} {{map|4 -1}} {{map|-1 5}}}}, but that would obscure the fact that it is the combination of two familiar commas (but that notation ''would'' be useful for expressing a matrix built out of multiple maps, as we will soon see).
+We can extend our angle bracket notation (technically called [https://en.wikipedia.org/wiki/Bra%E2%80%93ket_notation bra-ket notation, or Dirac notation]<ref>Bra-ket notation comes to RTT from quantum mechanics, not algebra.</ref>) to handle matrices by nesting rows inside columns, or columns inside rows ''(see Figure 5a)''. For example, we could have written our comma-basis like this: {{map|{{vector|-4 4 -1}} {{vector|-10 -1 5}}}}. Starting from the outside, the {{map|}} tells us to think in terms of a row. It's just that this row isn't a row of numbers, like the ones we've gotten used to by now, but rather a row of ''columns of'' numbers. So this row houses two such columns. Alternatively, we could have written this same matrix like {{vector|{{map|-4 -10}} {{map|4 -1}} {{map|-1 5}}}}, but that would obscure the fact that it is the combination of two familiar commas (but that notation ''would'' be useful for expressing a matrix built out of multiple maps, as we will soon see).
-Sometimes a comma basis may have only a single comma. That’s okay. A single vector can become a matrix. To disambiguate this situation, you could put the vector inside row brackets, like this: {{map|{{vector|-4 4 -1}}}}. Similarly, a single covector can become a matrix, by nesting inside column brackets, like this: {{vector|{{map|19 30 44}}}}.
+Sometimes a comma-basis may have only a single comma. That’s okay. A single vector can become a matrix. To disambiguate this situation, you could put the vector inside row brackets, like this: {{map|{{vector|-4 4 -1}}}}. Similarly, a single covector can become a matrix, by nesting inside column brackets, like this: {{vector|{{map|19 30 44}}}}.
-If a comma basis is the name for the matrix made out of commas, then we could say a “'''mapping'''” is the name for the matrix made out of maps. Why isn't this one a "basis", you ask? Well, it can be thought of as a basis too. It depends on the context. When you use the word "mapping" for it, you're treating it like a function, or a machine: it takes in intervals, and spits out new forms of intervals. That's how we've been using it here. But in other places, you may be thinking of this matrix as a basis for the infinite space of possible maps that could be combined to produce a matrix which works the same way as a given mapping, i.e. it tempers out the same commas. In these contexts, it might make more sense to call such a mapping matrix a "mapping-row basis".
+If a comma-basis is the name for the matrix made out of commas, then we could say a “'''mapping'''” is the name for the matrix made out of maps. Why isn't this one a "basis", you ask? Well, it can be thought of as a basis too. It depends on the context. When you use the word "mapping" for it, you're treating it like a function, or a machine: it takes in intervals, and spits out new forms of intervals. That's how we've been using it here. But in other places, you may be thinking of this matrix as a basis for the infinite space of possible maps that could be combined to produce a matrix which works the same way as a given mapping, i.e. it tempers out the same commas. In these contexts, it might make more sense to call such a mapping matrix a "mapping-row basis".
 And now you wonder why it's not just "map basis". Well, that's answerable too. It's because "map" is the analogous term to an "interval", but we're looking for the analogous term to a "comma". A comma is an interval which is tempered out. So we need a word that means a map which tempers out, and that term is "mapping-row".
-So, yes, that's right: maps are similar to commas insofar as — once you have more than one of them in your matrix — the possibilities for individual members immediately go infinite. Technically speaking, though, while a comma basis is a basis of the null-space of the mapping, a mapping-row basis is a ''row''-basis of the ''row''-space of the mapping.
+So, yes, that's right: maps are similar to commas insofar as — once you have more than one of them in your matrix — the possibilities for individual members immediately go infinite. Technically speaking, though, while a comma-basis is a basis of the null-space of the mapping, a mapping-row basis is a ''row''-basis of the ''row''-space of the mapping.
 One last note back on the bracket notation before we proceed: you will regularly see matrices across the wiki that use only square brackets on the outside, e.g. [{{map|5 8 12}} {{map|7 11 16}}] or [{{vector|-4 4 -1}} {{vector|-10 -1 5}}]. That's fine because it's unambiguous; if you have a list of rows, it's fairly obvious you've arranged them vertically, and if you've got a list of columns, it's fairly obvious you've arranged them horizontally. I personally prefer the style of using angle brackets at both levels — for slightly more effort, it raises slightly less questions — but using only square brackets on the outside should not be said to be wrong<ref>Besides, in most contexts the null-space of a linear mapping is thought of as a list of vectors, rather than a matrix, but it’s generally more helpful for us here to think of it smooshed together as a matrix.</ref>.
@@ Line 528: / Line 528: @@
 Working this out by hand goes like this (it is a standard linear algebra operation, so if you're comfortable with it already, you can skip this and other similar parts of these materials).
-So here's our starting point, the meantone|magic comma basis:
+So here's our starting point, the meantone|magic comma-basis:
 <math>
@@ Line 624: / Line 624: @@
 </math>
-And ta-da! You’ve found a mapping from a comma basis, and it is {{vector|{{map|19 30 44}}}}. In other words, for this temperament, you have converted a basis for its null-space to a row-basis for its mapping row-space. Feel free to try this with any other combination of two commas tempered out by this mapping-row.
+And ta-da! You’ve found a mapping from a comma-basis, and it is {{vector|{{map|19 30 44}}}}. In other words, for this temperament, you have converted a basis for its null-space to a row-basis for its mapping row-space. Feel free to try this with any other combination of two commas tempered out by this mapping-row.
-So why the anti-transpose sandwich? What we (and everyone) want in a canonical mapping is to have a triangle of zeros in the bottom left corner. What we want in a comma basis is also to have a triangle of zeros in the bottom left corner. But the comma basis is on the other side of duality from the mapping, so it must be transposed before we can apply our nullSpaceBasis[] function to it, because that function is designed for mappings. But when we transpose the comma basis we end up with the triangle of zeros in the top right. If we take the null-space of that and then transpose it back again, we don't get our canonical form of the mapping, we get a mapping with a triangle of zeros in the top right. The way to fix this is to anti-transpose instead of transpose, before and after taking the null-space. Because when you anti-transpose the comma basis, you still turn columns into rows, but this time the triangle of zeros stays on the bottom left.
+So why the anti-transpose sandwich? What we (and everyone) want in a canonical mapping is to have a triangle of zeros in the bottom left corner. What we want in a comma-basis is also to have a triangle of zeros in the bottom left corner. But the comma-basis is on the other side of duality from the mapping, so it must be transposed before we can apply our nullSpaceBasis[] function to it, because that function is designed for mappings. But when we transpose the comma-basis we end up with the triangle of zeros in the top right. If we take the null-space of that and then transpose it back again, we don't get our canonical form of the mapping, we get a mapping with a triangle of zeros in the top right. The way to fix this is to anti-transpose instead of transpose, before and after taking the null-space. Because when you anti-transpose the comma-basis, you still turn columns into rows, but this time the triangle of zeros stays on the bottom left.
 Here's the Wolfram Language implementation:
@@ Line 646: / Line 646: @@
-Notice how when writing our comma basis in Wolfram Language, we have to write it differently than we probably would otherwise. Wolfram doesn't understand RTT's angle bracket syntax for indicating how a matrix is sliced and diced; it supports only one way of writing matrices: as lists within lists, where the outermost list is always assumed to be vertical. So if we have a comma basis with two commas, we can't just write one comma and then the other; we have to do one element from each comma in a group at a time. Also, note that our output is within two layers of curly brackets; this is because it's a matrix with one row, not a vector with one column. None of this is a huge deal or anything, but again, it may just take a little getting used to.
+Notice how when writing our comma-basis in Wolfram Language, we have to write it differently than we probably would otherwise. Wolfram doesn't understand RTT's angle bracket syntax for indicating how a matrix is sliced and diced; it supports only one way of writing matrices: as lists within lists, where the outermost list is always assumed to be vertical. So if we have a comma-basis with two commas, we can't just write one comma and then the other; we have to do one element from each comma in a group at a time. Also, note that our output is within two layers of curly brackets; this is because it's a matrix with one row, not a vector with one column. None of this is a huge deal or anything, but again, it may just take a little getting used to.
 Now the null-space function, to take you from {{vector|{{map|19 30 44}}}} back to the matrix, is pretty much the same thing, but simpler! No need to anti-transpose. Just start at the augmentation step:
@@ Line 726: / Line 726: @@
 === the other side of duality ===
-So we can now convert back and forth between a mapping-row basis and a comma basis. We could imagine drawing a diagram with a line of duality down the center, with a temperament's mapping-row basis on the left, and its comma basis on the right. Either side ultimately gives the same information, but sometimes you want to come at it in terms of the maps, and sometimes in terms of the commas.
+So we can now convert back and forth between a mapping-row basis and a comma-basis. We could imagine drawing a diagram with a line of duality down the center, with a temperament's mapping-row basis on the left, and its comma-basis on the right. Either side ultimately gives the same information, but sometimes you want to come at it in terms of the maps, and sometimes in terms of the commas.
-So far we've looked at how to meet comma vectors to form a comma basis. Next, let's look at the other side of duality, and see how to form a mapping-row basis out of joining maps. In many ways, the approaches are similar; the line of duality is a lot like a mirror in that way.
+So far we've looked at how to meet comma vectors to form a comma-basis. Next, let's look at the other side of duality, and see how to form a mapping-row basis out of joining maps. In many ways, the approaches are similar; the line of duality is a lot like a mirror in that way.
 When we join two maps, we put them together into a matrix, just like how we put two vectors together into a matrix. But again, where vectors are vertical columns, maps are horizontal rows. So when we combine {{map|5 8 12}} and {{map|7 11 16}}, we get a matrix that looks like
@@ Line 1,000: / Line 1,000: @@
 === rank and nullity ===
-Let’s review what we’ve seen so far. 5-limit JI is 3-dimensional. When we have a rank-3 temperament of 5-limit JI, 0 commas are tempered out. When we have a rank-2 temperament of 5-limit JI, 1 comma is tempered out. When we have a rank-1 temperament of 5-limit JI, 2 commas are tempered out.<ref>Probably, a rank-0 temperament of 5-limit JI would temper 3 commas out. All I can think a rank-0 temperament could be is a single pitch, or in other words, everything is tempered out. So perhaps in some theoretical sense, a comma basis in 5-limit made out of 3 vectors, thus a square 3×3 matrix, as long as none of the lines are parallel, should minimally represent every interval in the space.</ref>
+Let’s review what we’ve seen so far. 5-limit JI is 3-dimensional. When we have a rank-3 temperament of 5-limit JI, 0 commas are tempered out. When we have a rank-2 temperament of 5-limit JI, 1 comma is tempered out. When we have a rank-1 temperament of 5-limit JI, 2 commas are tempered out.<ref>Probably, a rank-0 temperament of 5-limit JI would temper 3 commas out. All I can think a rank-0 temperament could be is a single pitch, or in other words, everything is tempered out. So perhaps in some theoretical sense, a comma-basis in 5-limit made out of 3 vectors, thus a square 3×3 matrix, as long as none of the lines are parallel, should minimally represent every interval in the space.</ref>
 There’s a straightforward formula here: <span><math>d - n = r</math></span>, where <span><math>d</math></span> is dimensionality, <span><math>n</math></span> is nullity, and <span><math>r</math></span> is rank. We’ve seen every one of those words so far except '''nullity'''. [[Nullity]] simply means the count of commas tempered out, or in other words, the count of commas in a basis for the null-space ''(see Figure 5c)''.
@@ Line 1,069: / Line 1,069: @@
 Because we're starting in 4D here, if we temper out one comma, we still have a rank-3 temperament, with 3 independent generators. Temper out two commas, and we have a rank-2 temperament, with 2 generators (remember, one of them is the period, which is usually the octave). And we’d need to temper out 3 commas here to pinpoint a single ET.
-The particular case I’d like to focus our attention on here is the rank-2 case. This is the first situation we’ve been able to achieve which boasts both an infinitude of matrices made from comma vectors which can represent the temperament by its comma basis, as well as an infinitude of matrices made from ET maps which can represent a temperament by its mapping-row basis. These are not contradictory. Let’s look at an example: septimal meantone.
+The particular case I’d like to focus our attention on here is the rank-2 case. This is the first situation we’ve been able to achieve which boasts both an infinitude of matrices made from comma vectors which can represent the temperament by its comma-basis, as well as an infinitude of matrices made from ET maps which can represent a temperament by its mapping-row basis. These are not contradictory. Let’s look at an example: septimal meantone.
 Septimal meantone may be thought of as the temperament which tempers out the meantone comma and the starling comma (126/125), or “meantone|starling”. But it may also be thought of as “meantone|marvel”, where the marvel comma is 225/224. We don’t even necessarily need the meantone comma at all: it can even be “starling|marvel”! This speaks to the fact that any temperament with a nullity greater than 1 has an infinitude of equivalent comma bases. It’s up to you which one to use.
@@ Line 1,108: / Line 1,108: @@
 maps the fourth (4/3, {{vector|2 -1 0 }}) to {{vector|0 1}}.
-It’s often the case that a temperament’s nullity is greater than 1 or its rank is greater than 1, and therefore we have an infinitude of equivalent ways of expressing the comma basis or the mapping-row basis. This can be problematic, if we want to efficiently communicate about and catalog temperaments. It’s good to have a standardized form in these cases. The approach RTT takes here is to get these matrices into '''“canonical” form'''. In plain words, this just means: we have a function which takes in a matrix and spits out a matrix of the same shape, and no matter which matrix we input from a set of matrices which we consider all to be equivalent to each other, it will spit out the same result. This output is what we call the “canonical” matrix, and it can therefore uniquely identify a temperament.
+It’s often the case that a temperament’s nullity is greater than 1 or its rank is greater than 1, and therefore we have an infinitude of equivalent ways of expressing the comma-basis or the mapping-row basis. This can be problematic, if we want to efficiently communicate about and catalog temperaments. It’s good to have a standardized form in these cases. The approach RTT takes here is to get these matrices into '''“canonical” form'''. In plain words, this just means: we have a function which takes in a matrix and spits out a matrix of the same shape, and no matter which matrix we input from a set of matrices which we consider all to be equivalent to each other, it will spit out the same result. This output is what we call the “canonical” matrix, and it can therefore uniquely identify a temperament.
-To be clear, canonical form isn’t necessary to avoid ambiguity: you will never find a comma basis that could represent more than one temperament.
+To be clear, canonical form isn’t necessary to avoid ambiguity: you will never find a comma-basis that could represent more than one temperament.
 I've seen many specialized matrix forms used in RTT for problems like this, such as "[[IRREF|integer canonical form]]", [https://en.wikipedia.org/wiki/Hermite_normal_form Hermite Normal Form], and maybe others. What we will be using here is a form I’ve developed recently in collaboration with Dave Keenan that we’re calling [[TBD canonical form]].<ref>Historically, Hermite Normal Form was used as if it gave a unique identifier for each temperament, when in fact it did not. It failed to remove possibly-hidden common factors in the columns of comma bases and rows of mapping-row bases, leading to situations which were named "[[torsion]]" and "[[contorsion]]", respectively. Hermite Canonical Form goes too far; it reduces the matrix's diagonals to all 1's or 0's, which loses important information for temperaments with non-octave periods. Integer canonical form removes such common factors without compromising non-octave periods, therefore truly giving a unique identifier, and also eliminating the need to deal with enfactored mappings or comma-bases.</ref>.
@@ Line 1,125: / Line 1,125: @@
 If you take the integer canonical form of {{vector|{{map|5 8 12}} {{map|7 11 16}}}}, that’s what you get. It’s also what you get if you take the integer canonical form of {{vector|{{map|12 19 28}} {{map|19 30 44}}}}, etc. That’s the power of canonicalization.
-To find the integer canonical form, we can combine the two processes we already know how to do: null-space for getting from a mapping-row basis to a comma basis, and anti-null-space to get from a comma basis to a mapping-row basis. Basically, to achieve canonical form of one type of basis, we convert it into the other type of basis, then back, and voilà: canonicalization.
+To find the integer canonical form, we can combine the two processes we already know how to do: null-space for getting from a mapping-row basis to a comma-basis, and anti-null-space to get from a comma-basis to a mapping-row basis. Basically, to achieve canonical form of one type of basis, we convert it into the other type of basis, then back, and voilà: canonicalization.
 For this, we need to up our game to Wolfram computable notebooks. You can click "Make Your Own Copy" in the top left of the screen if you want to modify this notebook to make your own calculations.
@@ Line 1,328: / Line 1,328: @@
 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 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.
@@ Line 1,391: / Line 1,391: @@
 [[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.
+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}}.
+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
@@ Line 1,622: / Line 1,622: @@
 |multimap
 |multicomma
-|comma basis
+|comma-basis
 |interval, comma
 |-