Magma includes a database containing most of the lattices explicitly presented in the Catalogue of Lattices maintained by Neil J.A. Sloane and Gabriele Nebe [NS01b].
Many standard lattices included in the Sloane & Nebe catalogue are not in the database as they may be obtained by applying Magma's standard lattice creation functions. Also omitted from the database are a small number of catalogued lattices defined over rings other than Z or Q.
The information available for any given lattice in the catalogue varies considerably. A similar variety is found in the Magma database version, although some data (generally either easily computable or rarely available in the catalogue) is omitted.
Where the Magma database does retain data, it is not altered from the data in the catalogue. Thus the caveat which comes with that catalogue remains relevant: "Warning! Not all the entries have been checked!"
A second version of the Lattice Database has been made available with Version 2.16 of Magma. It adds a few more lattices, contains more information about automorphism groups, and adds Θ-series as attributes. Furthermore, it removes some duplicates. The user should be warned that the numbering of lattices (and naming in some cases) differs between the two versions. The newer version, however, does not contain information about any Hermitian structure at the current time.
The entries of the database can be accessed in three ways:
This function returns a database object which contains information about the database.
This section gives the functions that enable the user to find out what is in the database.
Returns the number of lattices stored in the database.
Returns the largest dimension of any lattice in the database.
Returns the number of lattices of dimension d stored in the database.
Returns the number of lattices named N stored in the database. (This should always be 1 now).
Return the name and dimension of the i-th entry of the database D.
Return the name and dimension of the i-th entry of dimension d of the database D.
Return the name and dimension of the first entry of the database with name N.
Return the name and dimension of the i-th entry of the database with name N.
> D := LatticeDatabase(); > NumberOfLattices(D); 699The database contains 699 lattices. We get the set of all names in the database.
> names := {LatticeName(D,i): i in [1..#D]};
> #names; // No duplicate names anymore
699
> Random(names);
S4(5):2
> NumberOfLattices(D, "S4(5):2");
1
The following functions retrieve lattice information from the database.
TrustAutomorphismGroup: Bool Default: true
Returns the i-th entry (of dimension d or name N) from the database D as a lattice L.If the TrustAutomorphismGroup parameter is assigned false, then any data which claims to be the automorphism group will not be stored in L.
Returns a record which contains all the information about the i-th lattice stored in the database D (of dimension d or name N). The automorphism group is returned separately from the lattice and not stored in it.
> D := LatticeDatabase(); > NumberOfLattices(D, 6); 19 > L := Lattice(D, 6, 10); > L; Standard Lattice of rank 6 and degree 6 Minimum: 4 Inner Product Matrix: [4 1 2 2 2 2] [1 4 2 2 2 2] [2 2 4 1 2 2] [2 2 1 4 2 2] [2 2 2 2 4 1] [2 2 2 2 1 4]There may be more information stored than just what is returned by the Lattice function. We get the record containing all the stored lattice data.
> R := LatticeData(D, 6, 10); > Format(R); recformat<name, dim, lattice, minimum, kissing_number, is_integral, is_even, is_unimodular, is_unimodular_hermitian, modularity, group_names, group, group_order, hermitian_group_names, hermitian_group, hermitian_group_order, hermitian_structure>This lists all possible fields in the record. They may or may not be assigned for any particular lattice.
> R`lattice eq L; true > R`name; A6,1 > assigned R`kissing_number; true > R`kissing_number; 42 > assigned R`group; false > A := AutomorphismGroup(L); > A : Minimal; MatrixGroup(6, Integer Ring) of order 96 = 2^5 * 3The result of the Lattice call is equal to the lattice field of the data record. The kissing number was stored, but the automorphism group wasn't. We computed the group (as a matrix group over the integers) and found it has order 96.
There are a few facilities for computing with Hermitian lattices over an imaginary quadratic field or a quaternion algebra. However, these functions apply to a Gram matrix, and not a lattice per se. The main application is for automorphism groups that preserve a structure.
Given a matrix over an imaginary quadratic field or a quaternion algebra, return the conjugate transpose.
Given a matrix over an imaginary quadratic field or a quaternion algebra, expand it to a basis over the rationals.
Given a conjugate symmetric Gram matrix, compute the automorphism group.Various functions for matrix groups over associative algebras are available here, such as CharacterTable and IsConjugate which simply use a re-writing over the rationals, and InvariantForms which after using GHom needs to restrict to elements fixed by the quaterionic structure. Finally, there is QuaternionicGModule which will split a G-module over a quaternionic structure.
Given a matrix group over an associative algebra or an imaginary quadratic field, return a basis for the forms fixed by it.
Given a G-module M and I and J in the endomorphism algebra that anti-commute and whose squares are scalars, write G over the quaternionic structure given by I and J.
Given a conjugate-symmetric matrix over a quaternion algebra, compute the Moore determinant. This is the "normal" determinant, which is well-defined here because all the diagonal elements are rational, and thus there is no ambiguity between left/right division.
> G := SU(3, 3);
> chi := CharacterTable(G)[2];
> M := GModule(chi,Integers());
> E := EndomorphismAlgebra (M);
> while true do
> r := &+[Random([-2..2])*E.i : i in [1..4]];
> if r^2 eq -1 then break; end if;
> end while;
> while true do
> s := &+[Random([-2..2])*E.i : i in [1..4]];
> if s^2 eq -3 and r*s eq -s*r then break; end if;
> end while;
> MM := QuaternionicGModule(M, r, s);
> Discriminant(BaseRing(MM));
3
> MG := MatrixGroup(MM);
> IF := InvariantForms(MG); IF;
[
[1 -1/2*i + 1/6*k 1/3*k]
[1/2*i - 1/6*k 1 -1/3*j]
[-1/3*k 1/3*j 1]
]
> assert IsIsomorphic(G, MG);
> A<i,j,k> := QuaternionAlgebra<Rationals()|-1,-1>; > v := []; > v[1] := [2+2*i,0,0,0,0,0]; /* from Wilson's paper */ > v[2] := [2,2,0,0,0,0]; > v[3] := [0,2,2,0,0,0]; > v[4] := [i+j+k,1,1,1,1,1]; > v[5] := [0,0,1+k,1+j,1+j,1+k]; > v[6] := [0,1+j,1+j,1+k,0,1+k]; > V := [Vector(x) : x in v]; > W := [Vector([Conjugate(x) : x in Eltseq(v)]): v in V]; > M6 := Matrix(6,6,[(V[i],W[j])/2 : i,j in [1..6]]); /* 6-dim over A */ > time Q := QuaternionicAutomorphismGroup(M6); > assert #Q eq 503193600;
The same can be done for the Coxeter-Todd lattice.
> A<i,j,k> := QuaternionAlgebra<Rationals()|-1,-3>; > a := (1+i+j+k)/2; > M3 := Matrix(3,3,[2,a,-1, Conjugate(a),2,a, -1,Conjugate(a),2]); > time Q := QuaternionicAutomorphismGroup(M3); > assert #Q eq 12096;
One can also compute the automorphism group over the Eisenstein field, using InvariantForms on the realisation of this group as ShephardTodd(34).
> G := ShephardTodd(34); > IF := InvariantForms(G); // scaled Coxeter-Todd over Q(sqrt(-3)) > A := HermitianAutomorphismGroup(IF[1]); > assert IsIsomorphic(A,G);