Normal forms

Since a regular temperament can be represented by multiple equivalent val lists (aka mappings) or monzo lists (or comma lists), we have developed normal lists in order to uniquely identify each temperament.

Introduction to Hermite normal form

An integral matrix is a matrix whose entries are all integers. An important normalized form for integral matrices is Hermite normal form, and by using Hermite normal form we may define normalized forms of lists of intervals or monzos (aka comma lists) or lists of vals, the normal interval/monzo list and the normal val list.

There are slightly different definitions of Hermite normal form in use, and if you are using a computer program to compute it, you should take care that the same normal monzo or val list is finally achieved. The definition used by the Wikipedia article on Hermite form, probably the most standard, works as follows.

An n by m integral matrix H is in Hermite normal form if when we define a function F such that F (i) = 0 if all of the entries in the i-th column of H are 0, and otherwise F (i) is equal to the row number of the first nonzero entry in the i-th column, checking up from the bottom, i.e. from the n-th row, we have

1. If i > j, H[i, j] = 0 (H is upper triangular.)
2. F (i) is a function of the column number i.
3. F (i) = 0 if and only if all of the entries in the i-th column are 0.
4. F is an increasing function of the column number i, and becomes strictly increasing after F (i) becomes positive.
5. If k > F (i) > 0 then H[k, i] = 0; that is, F (i) is the row of the first nonzero entry in the i-th column, counting up from the bottom.
6. If F (i) > 0 then H[F (i), i] > 0; that is, the first nonzero entry in the i-th column, counting up from the bottom, is positive.
7. If F (i) > 0 and i < j then H[F (i), i] > H[F (i), j] ≥ 0; that is, the first nonzero entry in the i-th column, counting up from the bottom, is greater than any of the rest along that row, which however are all non-negative.

There is some redundancy in the statement of these conditions, but that does no harm.

Normal val list

Canonical form

If A is a list of n vals, we may write it as an n×m matrix, where the rows of the matrix are the vals, and m = π (p), where p is the prime limit. To get the canonical form, we do the following:

1. Defactor it.
2. Hermite reduce it.
3. Throw away all rows which consist of nothing but zeros, resulting in a k×m matrix.

For example, septimal meantone has the canonical form of [⟨1 0 -4 -13], ⟨0 1 4 10]], corresponding to generators of ~2/1 and ~3/1.

Positive generator form

The positive generator form is based on the canonical form, but the vals on the list correspond to a list of generators which are all positive (written additively) or equivalently greater than 1 (written multiplicatively).

To obtain this form, we find the Frobenius generators of the temperament – to break this down, we find the Moore–Penrose pseudoinverse of the k×m matrix, A⁺, and multiply this from the left by the row vector of JIP, J₀ = [1 log₂3 log₂5 … log₂p].

[math]\displaystyle{ G_\text{F} = J_0 A^+ }[/math]

If the i-th entry in the result is negative, multiply the corresponding val by -1. Return the result.

The "mapping" (though not the "Map to lattice") listed on temperament pages of this wiki are in this form. The generators in canonical form of septimal meantone is positive already, so its positive generator form is the same as its canonical form, [⟨1 0 -4 -13], ⟨0 1 4 10]], corresponding to generators of ~2/1 and ~3/1.

Equave-reduced generator form

The equave-reduced generator form is similar to the positive generator form, but the matrix is further normalized such that each generator is reduced by the formal prime represented by the first column of the matrix.

Septimal meantone in equave-reduced generator form is [⟨1 1 0 -3], ⟨0 1 4 10]], corresponding to generators of ~2/1 and ~3/2.

Minimal generator form

The minimal generator form (or mingen form) is a form specific to rank-2 temperaments, where the matrix is normalized such that the generator is positive and no greater than half the period.

Graham Breed's temperament finder uses this form for all rank-2 temperaments. Septimal meantone in minimal generator form is [⟨1 2 4 7], ⟨0 -1 -4 -10]], corresponding to generators of ~2/1 and ~4/3.

Normal interval list

Canonical form

Given a list of p-limit intervals, we can convert it to a normal list by the following procedure:

1. Convert the list to a list of monzos
2. Reverse the order of the elements of the monzos
3. Form a matrix whose rows are these reversed monzos
4. Defactor and Hermite reduce this matrix to Hermite normal form
5. Reverse (once again) the entries in each row of the Hermite normal form matrix, and use these re-reversed rows to form a new list of monzos
6. Discard all of the all-zero monzos, corresponding to the unison 1/1
7. Reverse the whole list (not the entries) of the remaining monzos
8. Convert this list back to a list of p-limit rational numbers

The result is the canonical form of the interval list. The set of elements of the original list generates a finitely generated free abelian subgroup of the positive rationals under multiplication, and therefore of any p-limit group it lives inside. The normalized list contains a minimal set of ratios, in an ordering of nondecreasing prime limit which is parsimonious in its use of higher limits. For example, if we normalize [81/80, 126/125] we obtain [80/81, 57344/59049]. The first interval is 5-limit, which is as small as possible. The second is 7-limit, which must be the case because the group these two generate is 7-limit. However, it uses only 2, 3 and 7 in its prime factorization, parsimoniously rejecting 5 as the next highest prime limit. Because abstract regular temperaments, where the prime mappings are known but not the specific tuning of the generators, are fully characterized by their kernel, the group of intervals they map to the unison, they can also be characterized by the regular interval list of a set of generators (called commas or unison vectors) for the kernel. The above normal interval list, for example, characterizes septimal meantone, defining the normal comma sequence of septimal meantone.

There is only one normal comma sequence that characterizes septimal meantone. But sometimes a temperament can be characterized by multiple normal comma sequences due to enfactoring. The canonical form of the comma list, however, requires that the normal comma sequence be defactored. There is only one such form of any temperament. For example, both [25/27, 35/36] and [25/27, 49/48] are normal, and they both characterize Beep. But the latter is enfactored, so the former is Beep's canonical form.

Normal interval lists can also be used to characterize the just intonation subgroups on which subgroup temperaments are defined and using which subgroup scales may be constructed. On the pages chromatic pairs, subgroup temperaments and just intonation subgroups can be found many examples; the subgroup lists are given in a form where generators of the subgroup are separated by periods so as to flag the fact that the list defines a subgroup. An example would be the Barbados subgroup, 2.3.13/5.

Positive ratio form

The positive ratio form is based on the canonical form but each ratio is greater than unity. To obtain this, simply replace any ratio smaller than 1 by its reciprocal. For example, the positive ratio form of septimal meantone is [81/80, 59049/57344]

Minimal ratio form

The minimal ratio form shows ratio-wise the simplest comma sequence sufficient to define the temperament, where the ratios are rated by the product of the numerator and the denominator, i.e. the Benedetti height.

This is the form shown in the "comma lists" of each temperament on this wiki.

Maple code

Below is Maple code for finding the normal interval and val list, given an interval list or a val list.

Code

log2 := proc(x) evalf(ln(x) / ln(2)) end:

# transpose of listlist w
transpos := proc(w)
    local u;
    u := Matrix(w);
    u := LinearAlgebra[Transpose](u);
    convert(u, listlist)
end:

# pseudoinverse of listlist w
pseudo := proc(w)
    local u;
    u := Matrix(w);
    u := LinearAlgebra[MatrixInverse](u, method='pseudo');
    convert(u, listlist)
end:

psu := proc(w) transpos(pseudo(w)) end:

# log2 of first n primes
pril := proc(n)
    local i, u;
    u := NULL;
    for i from 1 to n do
        u := u, log2(ithprime(i))
    od;
    [u]
end:

# reverse of list
revlist := proc(l)
    local i, v, e;
    e := nops(l);
    for i from 1 to e do
        v[i] := l[e - i + 1]
    od;
    convert(convert(v, array), list)
end:

orp := proc(w, p) padic[ordp](w, p) end:

# rank of p-limit of q
pim := proc(q)
    local r, i, p;
    r := 1;
    i := 0;
    while not (r = q) do
        i := i + 1;
        p := ithprime(i);
        r := r * p ^ orp(q, p)
    od;
    if i = 0 then RETURN(0) fi;
    i
end:

# prime limit of rational number q
plim := proc(q)
    ithprime(pim(q))
end:

# converts rational number q to monzo of length n
rat2monz := proc(q, n)
    local v, i;
    for i from 1 to n do
        v[i] := ordp(q, ithprime(i))
    od;
    convert(convert(v, array), list)
end:

# converts monzo to rational number
monz2rat := proc(m)
    local i, t;
    t := 1;
    for i from 1 to nops(m) do
        t := t * ithprime(i) ^ m[i]
    od;
    t
end:

# hermite normal form of listlist l
herm := proc(l)
    local M;
    M := Matrix(l);
    convert(convert(HermiteForm[Z](M), array), listlist)
end:

# normal interval list from list of intervals l
nori := proc(l)
    local i, p, u, v, w;
    p := 1;
    for i from 1 to nops(l) do
        p := max(p, plim(l[i]))
    od;
    u := [];
    for i from 1 to nops(l) do
        u := [op(u), revlist(rat2monz(l[i], p))]
    od;
    v := herm(u);
    for i from 1 to nops(l) do
        u := revlist(v[i]);
        u := monz2rat(u);
        w[i] := u
    od;
    u := [];
    for i from 1 to nops(l) do
        v := w[i];
        if v < 1 then v := 1 / v fi;
        if not v=1 then u := [op(u), v] fi
    od;
    revlist(u)
end:

norv := proc(l)
    # normal val list from list of vals l
    local u, v, w, i, n, a;
    u := herm(l);
    n := rnk(u);
    v := NULL:
    for i from 1 to n do
        v := v, u[i]
    od;
    v := [v];
    u := pseudo(v);
    w := pril(nops(l[1]));
    a := op(matmul(w, u));
    u := NULL;
    for i from 1 to n do
        if a[i] < 0 then u := u, -v[i] fi;
        if a[i] >= 0 then u := u, v[i] fi
    od;
    [u]
end: