Example LatNF_creation-examples (H32E1)

> K<s5> := NumberField(Polynomial([-5,0,1])); // Q(sqrt(5))
> L1 := NumberFieldLattice(K,3);
> G := Matrix(3,3,[K | 1,2,3, 2,s5,-1, 3,-1,0]);
> L2 := NumberFieldLattice(K,3 : Gram:=G); // with Gram matrix
> v1 := L1![1,2,3];
> v2 := L1![K.1,-1,2];
> L3 := NumberFieldLattice([Vector(v1),Vector(v2)]); // on vectors
> L4 := sub<L1|[v1,v2]>; // on LatNFElt's, same as L3
> M := Module(L3); // create the Dedekind module
> L5 := NumberFieldLattice(M); // and back to the NF lattice
> D := Dual(L3);
> L6 := D+L3;
> S := L3/K.1; // scaling
> L7 := S meet D; L7;
Number field lattice over Number Field with defining polynomial x^2 - 5
over the Rational Field with basis matrix
[-3*s5 + 2         7         0]
[  -s5 + 1         3         1]
> T3 := Matrix(3,3,[K | 1,2,3, 4,5,6, K.1,-1,-2]);
> L8 := L7*T3; // transform is same degree, operate on right
> T2 := Matrix(2,2,[K | 1,2, K.1,-1]);
> L9 := T2*L7; // lattice is 2-dim, operate on left (pseudobasis)
> assert Dimension(L9) eq 2 and Degree(L9) eq 3;
> DS := DirectSum(L2,L9); // 5-dimensional
> assert Dimension(DS) eq 3+2;
> O1 := OrthogonalComplement(L1,L3);
> O2 := OrthogonalComplement(L1,v1);
> O1;
Number field lattice over Number Field with defining polynomial x^2 - 5
over the Rational Field with basis matrix
[  1/2*(7*s5 + 7)    1/2*(s5 + 13) 1/2*(-3*s5 - 11)]
> O2;
Number field lattice over Number Field with defining polynomial x^2 - 5
over the Rational Field with basis matrix
[       -s5 - 1   1/2*(s5 + 1)              0]
[1/2*(3*s5 + 3)              0  1/2*(-s5 - 1)]

Attributes of Number Field Lattices

Basis(L) : LatNF -> [ModTupFldElt]

BasisMatrix(L) : LatNF -> Mtrx

Given the simple number field lattice L, return the basis, either as a sequence of vectors, or as a row matrix.

FreeBasis(L) : LatNF -> [ModTupFldElt]

Given a free lattice L, returns a basis for L.

LocalBasis(L, p) : LatNF, RngOrdIdl -> [ ModTupFldElt ]

LocalBasis(L, p) : Lat, RngInt -> [ ModTupFldElt ]

    Type: MonStgElt                     Default: ""

Returns a basis of a free lattice F in the quadratic space generated by L such that F agrees with L at the completion at p. If Type is specified, it must either be "Submodule" or "Supermodule". In which case F is either a sub- or supermodule of L.

PseudoBasis(L) : LatNF -> [ModTupFldElt]

PseudoBasisMatrix(L) : LatNF -> Mtrx

Given the number field lattice L, return the basis of its pseudobasis, either as a sequence of vectors, or as a row matrix.

PseudoMatrix(L) : LatNF -> PMat

Given the number field lattice L, return the pseudomatrix of its coefficient ideals and pseudobasis.

CoefficientIdeals(L) : LatNF -> SeqEnum

Given the number field lattice L, return its coefficient ideals.

Involution(L) : LatNF -> FldAut

Given the number field lattice L, return the involution with respect to which it is sesquilinear.

Generators(L) : LatNF -> SeqEnum

GeneratorMatrix(L) : LatNF -> Mtrx

Given the number field lattice L, return a sequence of generators. If the lattice is simple, these are just the standard basis vectors.

InnerProductMatrix(L) : LatNF -> Mtrx

Given the number field lattice L, return its inner product matrix. An error occurs if this is not known (for instance, when the Gram matrix was prescribed instead).

AmbientSpace(L) : LatNF -> SpcPlr

The ambient polar space in which the number field lattice L embeds.

EmbeddingSpace(L) : LatNF -> Mod

The embedding space of the number field lattice L.

MakeAmbientInnerProduct(~L, IP) : LatNF ->

Given the number field lattice L having no ambient inner product, attach the given matrix IP as the inner product matrix for L. The matrix IP is checked to be consistent with the given pseudobasis and pseudoGram matrices.

GramMatrix(L) : LatNF -> Mtrx

Given a simple number field lattice L, return its Gram matrix.

PseudoGramMatrix(L) : LatNF -> Mtrx

Given a number field lattice L, return the Gram matrix of its pseudobasis.

GramMatrix(L, S) : LatNF, [ ModTupFldElt ] -> AlgMatElt

GramMatrix(S) : [ LatNFElt ] -> AlgMatElt

    Half: BoolElt                       Default: false

Given a number field lattice L and a sequence S of vectors in the lattice, return the Gram matrix of these vectors. If Half is set to true, scales the Gram matrix by a half.

Rank(L) : LatNF -> RngIntElt

Dimension(L) : LatNF -> RngIntElt

The rank (or dimension) of the number field lattice L.

Degree(L) : LatNF -> RngIntElt

The degree (that is, dimension of the underlying ambient space) of the number field lattice L.

BaseRing(L) : LatNF -> FldNum

The number field over which the number field lattice L is defined.

CoordinateRing(L) : LatNF -> RngOrd

Order(L) : LatNF -> RngOrd

The order Z_K over which the number field lattice L is a module.

Determinant(L) : LatNF -> FldNumElt

The determinant of the Gram matrix of the simple number field lattice L. The determinant is well-defined up to squares of units on free lattices by first applying SimpleLattice if necessary.

Discriminant(L) : LatNF -> RngOrdFracIdl

Volume(L) : LatNF -> RngOrdFracIdl

The volume of the number field lattice L, which is the ideal generated by the determinants of all free sublattices. It is defined by (det)(G)∏_i (Nm)(J_i) where G is the pseudoGram matrix, J_i are the coefficient ideals, and (Nm)(I) = I /line(I), where .|-> /line(.) is the involution.

When L is quadratic of odd rank, the discriminant returns half of this quantity (the half-discriminant).

Norm(L) : LatNF -> RngOrdFracIdl

The norm of the lattice L, which is the ideal generated by the norms of all lattice elements. It equals ∑_i (Nm)(J_i) G_ii + ∑_{i, j} (Tr)(J_i G_ij /line(J)_j) where G is the pseudoGram matrix, the J_i are the coefficient ideals, and .|-> /line(.) is the involution.

Scale(L) : LatNF -> RngOrdFracIdl

The scale of the lattice L, which is the ideal generated by the inner products of pairs of lattice elements. It equals ∑_{i, j} J_i G_ij /line(J)_j, where G is the pseudoGram matrix, the J_i are the coefficient ideals, and .|-> /line(.) is the involution.

BadPrimes(L) : LatNF -> Set

    Even: BoolElt                       Default: false

The set of all maximal ideals of the base ring of L at which L is not unimodular. If Even is set, then the primes over 2 are included.

AuxiliaryForms(L) : LatNF -> [ AlgMatElt ]

Return a sequence of rational bilinear forms φ₁, ..., φ_d, defined by φ_i(x, y) = (Tr)(a_i x, y), where a_i runs over a basis of the number field K.

ElementaryDivisors(A, B) : LatNF, LatNF -> [ RngOrdFracIdl ]

The elementary divisors of the lattice A with respect to the lattice B. These are fractional ideals D₁ ⊆ ... ⊆D_n such that there exist pseudobases for A and B with the same basis vectors and coefficient ideals J_{B, i} = D_i J_{A, i}.

Discriminant(A, B) : LatNF, LatNF -> RngOrdFracIdl

The discriminant of the lattice A with respect to the lattice B. This is the product of the elementary divisors of A with respect to B.

Index(A, B) : LatNF, LatNF -> RngOrdFracIdl

The index of the lattice B in the lattice A.

JordanDecomposition(L, p) : LatNF, RndOrdIdl -> List, List, SeqEnum

Given a number field lattice L over some field K and a prime ideal of Z_K, a Jordan decomposition of L_p is an orthogonal decomposition of L_p into modular sublattices L₁, ..., L_r such that the p-adic valuations of the scales of these sublattices are strictly increasing.

The first return value is a list of matrices B₁, ..., B_r over K. The row spans of these lattices over Z_Kp yield a Jordan decomposition of L_p. The second and third return value list the Gram matrices and the p-adic valuations of the scales of the Jordan blocks respectively.

MaximalNormSplitting(L, p) : LatNF, RngOrdIdl -> SeqEnum, List

A maximal norm splitting of a number field lattice L at some prime ideal p is an orthogonal decomposition of L_p into unary and binary sublattices L₁, ..., L_r such that (scale)(L_i) ⊇(scale)(L_{i + 1}), (norm)(L_i) ⊇(norm)(L_{i + 1}) and (norm)(L_i^#) ⊆(norm)(L_{i + 1}^#) for all 1 ≤i < r. Here L_i^# denotes the dual of L_i.

GoodBasisOfNormGenerators(L, p) : LatNF, RngOrdIdl -> SeqEnum, SeqEnum

Let L be a number field lattice and let p be some prime ideal. A basis of norm generators is a tuple of vectors (x₁, ..., x_n) such that the norm of x₁ generates the norm of L_p and (x₂, ..., x_n) is a basis of norm generators for L ∩< x >^perp. It is called good if the p-adic valuation of (x_i, x_i) is no larger then the valuation of (x_{i + 2}, x_{i + 2}) for all 1 ≤i ≤r - 2. Note that a basis of norm generators does not need to generate L_p but only a proper sublattice.

The function returns such a good basis of norm generators lying in KL as well as the norms of the basis vectors.

GenusSymbol(L, p) : LatNF, RngOrdIdl -> SeqEnum, Any

    Uniformizer: RngElt                 Default: 

Let L₁, ..., L_r be a Jordan decomposition of L_p.

Suppose first p does not divide 2. The Genus symbol of L_p is a sequence of triples < r_i, s_i, d_i> where r_i and s_i are the rank and the p-adic valuation of the scale of L_i. Further, for quadratic lattices d_i = 1 if and only if det( π ^{- s_i} L_i) is a square in K_p ^* for some uniformizer π ∈K of p, otherwise d_i = - 1. For hermitian lattices, if the quadratic extension ramifies at p and s_i is even, d_i = 1 if and only if det( π ^{- s_i} L_i) is a norm in K_p ^* , and otherwise d = - 1. When either s_i is odd, or the quadratic extension does not ramify, d_i = 0. The genus symbol only depends on the genus of L and π. Hence the function returns π as a second argument. One can also specify which uniformizer to choose with the optional argument Uniformizer.

If p divides 2, the functions returns the fundamental invariants of L_p, see [O'M73, IX.93] for quadratic lattices, and [Jac62] for Hermitian lattices. It is a sequence of quadruples < r_i, s_i, w_i, a_i> where r_i and s_i are as before. Further, for quadratic lattices, w_i and a_i denote the p-adic valuation of the weight and a norm generator of L'_i = L₁ perp ... perp L_i respectively. For hermitian lattices, w_i denotes the p-adic valuation of the norm of L'_i, and a_i = det(L'_i). Note that in this case, the genus symbol does not only depend on the genus of L, but also on the chosen Jordan decomposition. Hence the function returns the sequence of Gram matrices for the lattices L_i as a second argument.

LocalGenus(L, p) : LatNF, RngOrdIdl -> SymGenLoc

    Uniformizer: RngElt                 Default: 

The local genus symbol of L at p.

Genus(L) : LatNF -> SymGen

    Proper: BoolElt                     Default: false

The genus symbol of L. If Proper is true, returns the proper genus.

HasseInvariant(L, p) : LatNF, RngOrdIdl -> RngIntElt

    AmbientSpace: BoolElt               Default: false

Computes the Hasse invariant of the quadratic space V generated by L at the maximal ideal p. It is defined as a product of Hilbert symbols ∏_i<j (a_i, a_j)_p where (a₁, ..., a_n) denotes some orthogonal basis of V.

If AmbientSpace is set, the function takes V to be the ambient space of the lattice L, which might have a larger rank than L.

WittInvariant(L, p) : LatNF, RngOrdIdl -> RngIntElt

    AmbientSpace: BoolElt               Default: false

Let V be the quadratic space generated by L (or its ambient space if AmbientSpace is set). If the rank of V is odd (even) let C be the (even part of) the Clifford algebra of V. Then C is a tensor product of quaternion algebras over K_p and thus central simple. The Witt invariant of L_p is defined to be +1 is C is split and -1 otherwise.

SpinorNorm(L, p) : LatNF, RngOrdIdl -> ModTupFld, Map, BoolElt

Let L be a definite number field lattice and let p be some prime ideal. The quotient K_p ^* / (K ^* )² is a vector space V over (GF)(2). Let g : V to K_p ^* / (K ^* )² be an isomorphism of abelian groups. Let W be the subspace of V corresponding to the elements in K_p ^* / (K ^* )² that are spinor norms of proper isometries of L_p. The intrinsic returns W, g as well as a boolean that is true if and only if W corresponds to the subgroup O_p ^* (K_p ^* )²/ (K_p ^* )². Note that the full space V can be recovered as Domain(g). The algorithm uses the results of M. Kneser [Kne57] and C. Beli [Bel03].

Mass(L) : LatNF -> FldRatElt

Mass(L) : Lat -> FldRatElt

LocalFactor(L, p) : LatNF, RngOrdIdl -> FldRatElt

Let L be a definite number field lattice of rank m over an extension E of some totally real number field K of degree n, such that [E:K] ≤2. Then the genus of L decomposes into finitely many isometry classes, represented by L₁, ..., L_h say. The mass of L is defined to be (Mass)(L) = ∑_i=1^h (1 /# (Aut)(L_i) ) . By Siegel's celebrated mass formula [Sie35] and its generalization [GHY01], the mass can be expressed as (Mass)(L) = 2 ^{- n r} L(M) τ(G) ∏_p λ_p(L) where the product runs over all maximal ideals p of the ring of integers of K, G is the isometry group (orthogonal or unitary), r is the rank of G, τ(G) is its Tamagawa measure, and L(M) is a product of special values of L-functions. When E = K (the quadratic case), this reads (Mass)(L) = 2^(-n ⌊(m /2) ⌋) ∏_i=1^(⌊(m - 1 /2) ⌋) ζ_K(1 - 2i) .L(χ, 1 - m/2) .∏_p λ_p(L). Here ζ_K denotes the usual Dedekind zeta function of K and L(χ, x) is only present if m is even, and in this case it is the L-series corresponding to χ. If the discriminant d = ( - 1)^m/2 det(V) is a square, let χ=1. In all other cases, χ is the non-trivial character of (Gal)(K(Sqrt(d))/K). When E/K is a quadratic extension (the hermitian case), the formula reads (Mass)(L) = 2^{1 - nm} ∏_i=1^m L(χⁱ, 1 - i) .∏_p λ_p(L). Here χ is the non-trivial character of (Gal)(E/K).

The above functions return the mass of L and the local factor λ_p(L) respectively. The local factors are known in many but not all cases, for example:

For odd prime ideals p, see W.T. Gan and J.K. Yu [GY00].

For unramified even prime ideals p, see S. Cho [Cho15].

If L_p is maximal, see G. Shimura [Shi99] or W.T. Gan, J. Hanke and J.K. Yu [GHY01].

For modular lattices, see M. Kirschmer [Kir16].

If none of the above results is applicable, a slow brute force search will be used to work out the local factors at the even prime ideals.

Neighbours(L, p) : LatNF, RngOrdIdl -> [LatNF], [RngIntElt]

    Limit: RngIntElt                    Default: Infinity()

    AutoOrbits: BoolElt                 Default: false

    CallBack: BoolElt                   Default: false

Given a number field lattice L and some prime ideal p such that L_p is modular, compute the p-neighbours of L i.e. the set of lattices M in the space generated by L such that L ∩M has index p in both, M and L.

The automorphism group of L acts on L. If L is definite and AutoOrbits is set to true, the algorithm will only return orbit representatives of this action and the second return value gives the lengths of these orbits.

If Limit is set to some positive integer, the algorithm stops once it has found that many neighbours.

The optional argument CallBack can be set to a function f which takes two arguments (X, N) and returns two booleans (k, c). For each neighbour (or orbit representative) N the intrinsic encounters, it calls f with the list X of the previously found lattices and the lattice N. If k is true, the lattice N is kept, i.e. appended to X. If c is true, the intrinsic continues, otherwise the enumeration stops immediately. (Note that the enumeration still stops once the list X contains Limit lattices.)

IteratedNeighbours(L, p) : LatNF, RngOrdIdl -> [LatNF]

    Limit: RngIntElt                    Default: Infinity()

    UseAuto: BoolElt                    Default: true

Computes a system of representatives of the isometry classes of all lattices that can be reached from a definite number field lattice L by repeatedly applying the p-neighbour construction. The lattice L_p must be modular.

If UseAuto is set, the algorithm will make use of the automorphism groups of the lattices it encounters.

If Limit is set to some positive integer, the algorithm stops once it has found that many isometry classes.

GenusRepresentatives(L) : LatNF -> [LatNF], Assoc

    NaturalAction: BoolElt              Default: true

    Proper: BoolElt                     Default: false

    UseAuto: BoolElt                    Default: true

    ThetaPrec: RngIntElt                Default: 25

    BadPrimes: BoolElt                  Default: true

    Limit: RngIntElt                    Default: Infinity()

    UseMass: BoolElt                    Default: true

Returns a sequence of representatives of the isometry classes in the genus of the number field lattice L. If the lattice is definite, also returns an associative array whose keys are isometry invariants of the lattice (theta series with precision ThetaPrec), and values the index in the sequence of genus representatives. The lattice L is supposed to have rank at least 3. If NaturalAction is set to true, the representatives returned lie in the same polar space as L. If Proper is set to true, returns representatives for proper isometry classes. If UseMass is set to false, does not use the mass formula as a stopping condition, and compute the entire neighbour closure. If BadPrimes is set to false, does not iterate over neighbors at bad primes. If Limit is set to some integer, the algorithm stops once it has enumerated that many lattices. In the definite case, the algorithm will make use of the automorphism groups of the representatives, unless UseAuto is set to false.

The algorithm consists of two steps:

1.

Enumerate all isometry classes in the spinor genus of L. For indefinite lattices, this step becomes void since spinor genus and isometry classes coincide thanks to Strong Approximation. In the definite case, iterated neighbours are computed at some suitable small prime ideal.

2.

Enumerate the spinor genera in the genus of L. This step is well understood in theory, see for example [O'M73, X.102]. Using a computationally more accessible variation of this description [Lor16], [Kir16], the algorithm then chooses several neighbours that are known to switch spinor genera.

> K := NumberField(Polynomial([5,0,1])); // Q(sqrt(-5))
> O := Integers(K);
> p2 := Factorization(2*O)[1][1]; // nonprincipal
> Js := [(2*O)/p2,2*O];
> v1 := Vector([K!1,0,0]);
> v2 := Vector([K!0,K.1,0]);
> L1 := NumberFieldLattice([v1,v2] : Ideals:=Js);
> assert not IsFree(L1); // not free
> assert not IsSimple(L1); // and not simple
> PseudoBasisMatrix(L1); // BasisMatrix does not work
[  1   0   0]
[  0 K.1   0]
> PseudoGramMatrix(L1);
[ 1  0]
[ 0 -5]
> CoefficientIdeals(L1);
[ Ideal of O Basis: [1 1]
                    [0 2],
  Principal Ideal of O, Generator: [2, 0] ]
> Generators(L1); // three of these, though L1 has dimension 2
[
    ( -3*$.1 - 7 -2*$.1 + 50           0),
    (  44*$.1 + 1100 1770*$.1 - 4130               0),
    ( 176*$.1 + 1628 2242*$.1 - 7080               0)
]
> assert #$1 eq 3 and Dimension(L1) eq 2;
> assert Degree(L1) eq 3 and Rank(L1) eq 2;
> assert BaseRing(L1) eq K;
> Discriminant(L1); // same as Volume
Principal Ideal Generator: [-40, 0]
> Norm(K.1*L1);
Principal Ideal of O, Generator: [10, 0]
> // now we take the direct sum of L1 with itself
> // which is free, and thus we can use other intrinsics
> D := DirectSum([L1,L1]);
> assert IsFree(D); // D itself is not in simple form
> Determinant(D); // works, as D is free
1600
> S := SimpleLattice(D);
> BasisMatrix(S); // works, while for D would not
[-3*K.1 - 5 -4*K.1 + 20 0 0 0 0]
[12*K.1 - 84 -100*K.1 - 20 0 5*K.1 - 1 0 0]
[-72*K.1 + 54 100*K.1 + 370 0 -7*K.1 - 17 -8*K.1 + 50 0]
[1080*K.1 - 864 -1560*K.1 - 5520 0 108*K.1 + 252 114*K.1 - 760 0]
> assert #Generators(S) eq 4; // same as the basis vectors

    Perestroika: BoolElt                Default: false

    UseLLL: BoolElt                     Default: false

    Perestroika: BoolElt                Default: false

    Even: BoolElt                       Default: false

    AmbientSpace: BoolElt               Default: false

    CheckIsometricSpaces: BoolElt       Default: true

    AmbientSpace: BoolElt               Default: false

    AmbientSpace: BoolElt               Default: false

    NaturalAction: BoolElt              Default: false

    Check: BoolElt                      Default: false

    NaturalAction: BoolElt              Default: false

    NaturalAction: BoolElt              Default: false

    Negatives: BoolElt                  Default: true