# Normal lists

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 *p*-limit musical intervals (or monzos) or lists of vals, the **normal interval/monzo list** and the **normal val list**.

Another important normalized form for integral matrices is what Kite Giedraitis has dubbed the IRREF, the **integral reduced row echelon form**. It is the reduced row echelon form made integral by multiplying each row of the matrix by the least common multiple of all denominators in that row. It differs from the Hermite normal form in that each pivot is the only nonzero entry in its column. For a monzo list, it has the advantage of limiting the appearance of the *N* highest primes to only one comma each (where *N* is the codimension), isolating each prime's effect on the pergen, but has the disadvantage that the commas tend to have high odd limits, and the comma list may have torsion. Sometimes the IRREF is identical to the Hermite normal form.

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

- If
*i*>*j*, H[*i*,*j*] = 0 (H is upper triangular.) *F*(*i*) is a function of the column number*i*.*F*(*i*) = 0 if and only if all of the entries in the*i*-th column are 0.*F*is an increasing function of the column number*i*, and becomes strictly increasing after*F*(*i*) becomes positive.- 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. - 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. - 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 interval list

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

- Convert the list to a list of monzos
- Reverse the order of the elements of the monzos
- Form a matrix whose rows are these reversed monzos
- Hermite reduce this matrix to Hermite normal form
- 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
- Discard all of the all-zero monzos, corresponding to the unison 1/1
- Reverse the whole list (not the entries) of the remaining monzos
- Convert this list back to a list of
*p*-limit rational numbers - For any number
*q*< 1 on this list, replace*q*with 1/*q*

The result is a normal 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 generators, each greater than zero, 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 [81/80, 59049/57344]. 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. However, if a requirement is added that the normal comma sequence be torsion-free, then there is only one characteristic normal comma sequence, and we can speak of *the* normal comma sequence of any temperament. For example, both [27/25, 21/20] and [27/25, 49/48] are normal, and they both characterize Beep. But the latter has torsion, so Beep's normal comma sequence is the former.

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.

In each temperament page on this wiki, however, the "comma lists" are not normal interval lists as defined above. Instead, it shows ratio-wise the simplest comma sequence sufficient to define the temperament.

## Normal val list

If L 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 normal val list, we do the following:

- Hermite reduce the matrix for L
- Throw away all rows which consist of nothing but zeros, resulting in a
*k*×*m*matrix - Find the Moore–Penrose pseudoinverse of the
*k*×*m*matrix, and multiply this from the left by the row vector 1200·[1 log_{2}3 log_{2}5 … log_{2}*p*]. If the*i*-th entry in the result is negative, multiply the corresponding val by -1. Return the result as the normalized val list.

The point of steps two and three is that now the vals on the list correspond to a list of generators which are all positive (written additively) or equivalently greater than 1 (written multiplicatively). Just as a normal comma list can be used to classify an abstract regular temperament, so can a normal val list. The val list is what on Graham Breed's web site is called a "mapping", put into a canonical form. The "Maps" (though not the "Map to lattice") listed on temperament pages of this wiki are all normal val lists; an example would be [⟨1 0 -4 -13], ⟨0 1 4 10]], the normal val list for septimal meantone. Using this as input, the output is 1199.25¢, 1899.45¢ (tempered 2/1, tempered 3/1).

## Maple code

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

```
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:
```