Enumeration of isometries

One of the main features of this project is the enumeration of even lattices equipped with an isometry of finite order. It is based on an implementation of the algorithms of [BH23] for isometries whose order has at most 2 prime divisors. Note that such algorithms have been generalized to cover all finite orders using an iterative procedure and Nikulin's theory of equivariant primitive extensions (also known as orthogonal primitive extensions).

We guide the user here to the global aspects of the available theory, and we refer to the paper [BH23] for further reference.

Admissible triples

Roughly speaking, for a prime number $p$ , a $p$ -admissible triple $(A, B, C)$ is a triple of integer lattices such that, in some cases, $C$ can be obtained as a primitive extension $A \oplus B \to C$ where one can glue along $p$ -elementary subgroups of the respective discriminant groups of $A$ and $B$ . Note that not all admissible triples satisfy this extension property.

For instance, if $f$ is an isometry of an integer lattice $C$ of prime order $p$ , then for $A := \ker \Phi_1(f)$ and $B := \ker \Phi_p(f)$ , one has that $(A, B, C)$ is $p$ -admissible (see Lemma 4.15. in [BH23]).

We say that a triple $(G_A, G_B, G_C)$ of genus symbols for integer lattices is $p$ -admissible if there are some lattices $A \in G_A$ , $B \in G_B$ and $C \in G_C$ such that $(A, B, C)$ is $p$ -admissible.

We use Definition 4.13. and Algorithm 1 of [BH23] to implement the necessary tools for working with admissible triples. Most of the computations consists of local genus symbol manipulations and combinatorics. The code also relies on enumeration of integer genera with given signatures, determinant and bounded scale valuations for the Jordan components at all the relevant primes (see integer_genera).

admissible_triples — Method

admissible_triples(
  G::Union{ZZGenus, ZZLat, ZZLatWithIsom},
  p::Int;
  IrA::AbstractVector{Int}=0:rank(G),
  IpA::AbstractVector{Int}=0:rank(G),
  InA::AbstractVector{Int}=0:rank(G),
  IrB::AbstractVector{Int}=0:rank(G),
  IpB::AbstractVector{Int}=0:rank(G),
  InB::AbstractVector{Int}=0:rank(G),
  b::Int=0,
) -> Vector{Tuple{ZZGenus, ZZGenus}}

Given a $\mathbb Z$ -genus $G$ and a prime number $p$ , return all tuples of $\mathbb Z$ -genera $(A, B)$ such that $(A, B, G)$ is $p$ -admissible and $B$ is of rank divisible by $p-1$ .

One can choose the ranges IrA, IpA and InA in which to take the rank, the positive signature and negative signature of A respectively. Similarly for B by choosing IrB, IpB and InB.

If b is set to 0, we allow in output the trivial pair, i.e. when $B$ is the genus of rank 0 lattices. Otherwise, if b is set to 1, the trivial pair is discarded.

Alternatively, one can choose as input a lattice L or a lattice with isometry Lf.

Enumeration functions

We give an overview of the functions implemented for the enumeration of the isometries of even $\mathbb{Z}$ -lattices. For more details such as the proof of the algorithms and the theory behind them, we refer to [BH23] and references therein.

The hermitian case

For an irreducible reciprocal polynomial $\chi$ and a genus symbol $G$ of integral integer lattices, if the equation order $\mathbb{Z}[\chi]$ is maximal, one can compute representatives of isomorphism classes of lattices with isometry $(L, f)$ such that $L\in G$ and $\chi(f) = 0$ .

representatives_of_hermitian_type — Method

representatives_of_hermitian_type(
  G::Union{ZZGenus, ZZLat},
  min_poly::Union{ZZPolyRingElem, QQPolyRingElem},
  fix_root::Int = -1;
  first::Bool=false,
  cond::Vector{Int}=Int[-1, -1, -1],
  genusDB::Union{Nothing, Dict{ZZGenus, Vector{ZZLat}}}=nothing,
  root_test::Bool=false,
) -> Vector{ZZLatWithIsom}

Given a nonempty genus of integer lattices $G$ and a polynomial min_poly which is irreducible over $\mathbb Q$ and so that the equation order of the associated number field is maximal, return a complete list of representatives for the isomorphism classes of pairs $(M, g)$ consisting of a lattice $M$ in $G$ and $g \in O(M)$ is an isometry of minimal polynomial min_poly

One can also provide a representative $L$ of $G$ instead.

The value $n$ of fix_root matters only when min_poly is cyclotomic. In the case where min_poly is the $n$ th cyclotomic polynomial, the function returns only one generator for every conjugacy classes of finite cyclic groups generated by an isometry of minimal polynomial min_poly

If first is set to true, only return the first representative computed.

Note that if G is trivial, the algorithm returns the trivial lattice with isometry by default.

For the advanced users

When using this function in a larger algorithm, one can use some keyword arguments which can be carried along the computations.

by setting the values in cond to the desired values (in order: rank, positive signature, negative signature), one can control whether the genus $G$ in input has the good rank or signatures;
if available, one can use any database of genera of definite lattices using the keyword argument genusDB (which should be a dictionary whose keys are genus symbols, and the corresponding value is a list of lattices of this genus);
if root_test is set to true, the genus enumeration algorithm determines whether any new genus of negative definite lattices to be enumerated consists of lattices of maximum $-2$ . In such a case, the enumeration is skipped.

Examples

julia> L = root_lattice(:A, 6)
Integer lattice of rank 6 and degree 6
with gram matrix
[ 2   -1    0    0    0    0]
[-1    2   -1    0    0    0]
[ 0   -1    2   -1    0    0]
[ 0    0   -1    2   -1    0]
[ 0    0    0   -1    2   -1]
[ 0    0    0    0   -1    2]

julia> chi = cyclotomic_polynomial(7)
x^6 + x^5 + x^4 + x^3 + x^2 + x + 1

julia> reps = representatives_of_hermitian_type(L, chi)
1-element Vector{ZZLatWithIsom}:
 Integer lattice with isometry of finite order 7

julia> is_of_hermitian_type(reps[1])
true

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

In the case of finite order isometries, when $\chi$ is cyclotomic, one can use as a shortcut the following function instead:

representatives_of_hermitian_type — Method

representatives_of_hermitian_type(
  G::Union{ZZGenus, ZZLat},
  m::Int,
  fix_root::Int = -1;
  first::Bool=false,
  cond::Vector{Int}=Int[-1, -1, -1],
  genusDB::Union{Nothing, Dict{ZZGenus, Vector{ZZLat}}}=nothing,
  root_test::Bool=false,
)  -> Vector{ZZLatWithIsom}

Given a nonempty genus of integer lattices $G$ , return a list of representatives of isomorphism classes of pairs $(M, g)$ consisting of a lattice $M$ in $G$ and $g \in O(M)$ is an isometry of minimal polynomial $\Phi_m(X)$ , the $m$ th cyclotomic polynomial.

If $m = 1, 2$ , this goes back to enumerating $G$ as a genus of integer lattices.

If the value of fix_root is exactly $m$ , then the function returns only one generator for every conjugacy classes of finite cyclic groups generated by an isometry of minimal polynomial $\Phi_m(X)$ .

One can also provide a representative $L$ of $G$ instead.

If first is set to true, only return the first representative computed.

Note that if G is trivial, the algorithm returns the trivial lattice with isometry by default.

For the advanced users

When using this function in a larger algorithm, one can use some keyword arguments which can be carried along the computations.

by setting the values in cond to the desired values (in order: rank, positive signature, negative signature), one can control whether the genus $G$ in input has the good rank or signatures;
if available, one can use any database of genera of definite lattices using the keyword argument genusDB (which should be a dictionary whose keys are genus symbols, and the corresponding value is a list of lattices of this genus);
if root_test is set to true, the genus enumeration algorithm determines whether any new genus of negative definite lattices to be enumerated consists of lattices of maximum $-2$ . In such a case, the enumeration is skipped.

Examples

julia> L = root_lattice(:A, 4)
Integer lattice of rank 4 and degree 4
with gram matrix
[ 2   -1    0    0]
[-1    2   -1    0]
[ 0   -1    2   -1]
[ 0    0   -1    2]

julia> reps = representatives_of_hermitian_type(L, 5)
1-element Vector{ZZLatWithIsom}:
 Integer lattice with isometry of finite order 5

julia> is_of_hermitian_type(reps[1])
true

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

The generic case

The algorithms from [BH23] are specialized on the requirement for the input and regular users are not expected to known which function to choose for their purpose. We therefore provide a generic function which allows one to compute a complete of representatives for the isomorphism classes of even lattices equipped with an isometry of finite order.

enumerate_classes_of_lattices_with_isometry — Method

enumerate_classes_of_lattices_with_isometry(
  G::Union{ZZGenus, ZZLat},
  m::Int;
  char_poly::Union{ZZPolyRingElem, QQPolyRingElem, Nothing}=nothing,
  min_poly::Union{ZZPolyRingElem, QQPolyRingElem, Nothing}=nothing,
  rks::Vector{Tuple{Int, Int}}=Tuple{Int, Int}[],
  pos_sigs::Vector{Tuple{Int, Int}}=Tuple{Int, Int}[],
  neg_sigs::Vector{Tuple{Int, Int}}=Tuple{Int, Int}[],
  eiglat_cond::Dict{Int64, Vector{Int64}}=Dict{Int64, Vector{Int64}}(),
  fix_root::Int=-1,
  genusDB::Union{Nothing, Dict{ZZGenus, Vector{ZZLat}}}=nothing,
  root_test::Bool=false,
  keep_partial_result::Bool=false,
) -> Vector{ZZLatWithIsom}

Given an even integer lattice $L$ , return a complete set of representatives for the isomorphism classes of lattices with isometry $(M, g)$ where $M$ is in the genus of $L$ , and $g$ is an isometry of $M$ of finite order $m$ . Alternatively, one can input a given genus symbol $G$ for even integer lattices as an input –- the function first computes a representative of $G$ .

For every $(M, g)$ in output, one may decide on the minimal polynomial (resp. the characteristic polynomial) of $g$ by setting the keyword argument min_poly (resp. char_poly) to the desired value. Moreover, one can also decide on the rank, positive signature and negative signature of the eigenlattices of $(M, g)$ using the keyword arguments rks, pos_sigs and neg_sigs respectively. Each list should consist of tuples $(k, i)$ where $k$ is a divisor of $p*m$ and $i$ is the value to be assigned for the given property (rank, positive/negative signature) to the corresponding $\Phi_k$ -eigenlattice. All these conditions will be first condensed in a dictionary keeping track, for each divisor $k$ of $p*m$ of the potential rank rk, positive signature pk and negative signature nk of the corresponding $\Phi_k$ -eigenlattice. The keys of such dictionary are the divisors $k$ , and the corresponding value is the vector [rk, pk, nk]. Any undetermined value will be set automatically to $-1$ by default. If one already knows such a dictionary, one can choose it as input under the keyword argument eiglat_cond.

For the advanced users

When using this function, one can use some extra keyword arguments which are carried along the computation:

by setting the value of fix_root to a certain integer $k$ , the function only computes one generator for every conjugacy class of finite cyclic groups when computing the corresponding $\Phi_k$ -kernel sublattices;
if available, one can use any database of genera of definite lattices using the keyword argument genusDB (which should be a dictionary whose keys are genus symbols, and the corresponding value is a list of lattices of this genus);
if root_test is set to true, the genus enumeration algorithm determines whether any new genus of negative definite lattices to be enumerated consists only of lattices of maximum $-2$ . In such a case, the enumeration is skipped;
by setting keep_partial_result to true, the function returns all pairs of lattices of isometries which have been computed.

Examples

julia> r = enumerate_classes_of_lattices_with_isometry(root_lattice(:A, 3), 4; rks=[(1, 0)])
1-element Vector{ZZLatWithIsom}:
 Integer lattice with isometry of finite order 4

julia> rank(invariant_lattice(r[1]))
0

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

As a remark: if $n = p_1^{e_1}p_2^{e_2}...p_k^{e_k}$ is the chosen order, with $p_1 < p_2 < ... < p_k$ distinct prime numbers and $e_i > 0$ for all $1\leq i\leq k$ , then the previous function computes first iteratively representatives for all classes in the given genus with an isometry of order finite $p_k^{e_k}$ . Then, the function iteratively increases the order to be $p_{k-1}^{e_{k-1}}p_k^{e_k}$ , and so on until $n$ .

In particular, the current naive approach requires to determine representatives for the isomorphism classes of even lattices with isometry of order dividing $n$ , for some divisors of $n$ . Hence, if $n$ has many divisors, such computations can be expensive. We do not recommend to use such a method for lattices of large rank or isometries of high order as the computations could possibly take several weeks. Interested users may look into the next section for more advanced methods, to be used on a larger framework.

Underlying machinery

Here is a list of the algorithmic machinery provided by Brandhorst and Hofmann in [BH23], and further extended by Muller, which is used by the previous enumerating functions. The functions goes from the more specialized method, to the most generic one.

representatives_of_hermitian_type — Method

representatives_of_hermitian_type(
  Lf::ZZLatWithIsom,
  m::Int = 1,
  fix_root::Int = -1;
  cond::Vector{Int}=Int[-1, -1, -1],
  genusDB::Union{Nothing, Dict{ZZGenus, Vector{ZZLat}}}=nothing,
  root_test::Bool=false,
)  -> Vector{ZZLatWithIsom}

Given a lattice with isometry $(L, f)$ of finite hermitian type, i.e. $f$ is of finite order $n$ and its minimal polynomial is irreducible cyclotomic, and a positive integer $m$ , return a complete set of representatives for the isomorphism classes of lattices with isometry $(M, g)$ of finite hermitian type such that the type of $(M, g^m)$ is equal to the type of $(L, f)$ .

Note that in this case, the isometries $g$ 's are of order $nm$ .

If the value of fix_root is exactly $nm$ , then the function returns only one generator for every conjugacy classes of finite cyclic groups generated by an isometry $g$ as before.

Note that if Lf is trivial, the algorithm returns Lf by default.

See also type(::ZZLatWithIsom).

For the advanced users

When using this function in a larger algorithm, one can use some keyword arguments which can be carried along the computations.

by setting the values in cond to the desired values (in order: rank, positive signature, negative signature), one can control whether the lattice $L$ in input has the good rank or signatures;
if available, one can use any database of genera of definite lattices using the keyword argument genusDB (which should be a dictionary whose keys are genus symbols, and the corresponding value is a list of lattices of this genus);
if root_test is set to true, the genus enumeration algorithm determines whether any new genus of negative definite lattices to be enumerated consists of lattices of maximum $-2$ . In such a case, the enumeration is skipped.

Examples

julia> L = root_lattice(:A, 2);

julia> Lf = integer_lattice_with_isometry(L);

julia> reps = representatives_of_hermitian_type(Lf, 6)
1-element Vector{ZZLatWithIsom}:
 Integer lattice with isometry of finite order 6

julia> is_of_hermitian_type(reps[1])
true

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

splitting_of_hermitian_type — Method

splitting_of_hermitian_type(
  Lf::ZZLatWithIsom,
  p::IntegerUnion,
  b::Int = 0;
  eiglat_cond::Dict{Int, Vector{Int}}=Dict{Int, Vector{Int}}(),
  fix_root::Int=-1,
  genusDB::Union{Nothing, Dict{ZZGenus, Vector{ZZLat}}}=nothing,
  root_test::Bool=false,
  check::Bool=true,
) -> Vector{ZZLatWithIsom}

Given an even lattice with isometry $(L, f)$ of hermitian type with $f$ of finite order $m$ , and given a prime number $p$ , return a complete set of representatives for the isomorphism classes of lattices with isometry $(M, g)$ such that the type of $(M, g^p)$ is equal to the type of $(L, f)$ .

The integer b can be set to be 0 or 1, depending on whether one allows Lf to be among the outputs or not. For instance, setting b = 1 would enforce every $(M, g)$ in output to satisfy that $g$ has order $p*m$ .

For every $(M, g)$ in output, one may decide on the rank r, the positive signature p and the negative signature n of the eigenlattices of $(M, g)$ using the keyword argument eiglat_cond. It should consist of a dictionary where each key is a divisor of $p*m$ , and the corresponding value is a tuple (r, p, n) of integers. Any undetermined value can be set to a negative number; for instance $(-1, 2, -4)$ means that the associated eigenlattice must have positive signature 2, without restriction on its rank and negative signature.

If the keyword argument check is set to true, the function tests whether $(L, f)$ is of hermitian type.

For the advanced users

When using this function, one can use some extra keyword arguments which are carried along the computation:

by setting the value of fix_root to a certain integer $k$ , the function only computes one generator for every conjugacy class of finite cyclic groups when computing the corresponding $\Phi_k$ -kernel sublattices;
if available, one can use any database of genera of definite lattices using the keyword argument genusDB (which should be a dictionary whose keys are genus symbols, and the corresponding value is a list of lattices of this genus);
if root_test is set to true, the genus enumeration algorithm determines whether any new genus of negative definite lattices to be enumerated consists only of lattices of maximum $-2$ . In such a case, the enumeration is skipped.

Examples

julia> L = root_lattice(:A, 2);

julia> f = matrix(QQ, 2, 2, [0 1; -1 -1]);

julia> Lf = integer_lattice_with_isometry(L, f);

julia> is_of_hermitian_type(Lf)
true

julia> reps = splitting_of_hermitian_type(Lf, 2)
2-element Vector{ZZLatWithIsom}:
 Integer lattice with isometry of finite order 6
 Integer lattice with isometry of finite order 3

julia> all(is_of_hermitian_type, reps)
true

julia> is_of_same_type(Lf, reps[1]^2)
true

julia> is_of_same_type(Lf, reps[2]^2)
true

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

splitting_of_prime_power — Method

splitting_of_prime_power(
  Lf::ZZLatWithIsom,
  p::Int,
  b::Int = 0;
  eiglat_cond::Dict{Int, Vector{Int}}=Dict{Int, Vector{Int}}(),
  fix_root::Int=-1,
  genusDB::Union{Nothing, Dict{ZZGenus, Vector{ZZLat}}}=nothing,
  root_test::Bool=false,
) -> Vector{ZZLatWithIsom}

Given an even lattice with isometry $(L, f)$ with $f$ of order $m = q^e$ for some prime number $q$ and a prime number $p \neq q$ , return a complete set of representatives for the isomorphism classes of lattices with isometry $(M, g)$ such that the type of $(M, g^p)$ is equal to the type of $(L, f)$ . Note that $e$ can be 0, in which case $f = id$ is trivial.

For every $(M, g)$ in output, one may decide on the rank rM, the positive signature pM and the negative signature nM of the eigenlattices of $(M, g)$ using the keyword argument eiglat_cond. It should consist of a dictionary where each key is a divisor of $p*m$ , and the corresponding value is a tuple (rM, pM, nM) of integers. Any undetermined value can be set to a negative number; for instance $(-1, 2, -4)$ means that the associated eigenlattice must have positive signature 2, without restriction on its rank and negative signature.

For the advanced users

When using this function, one can use some extra keyword arguments which are carried along the computation:

by setting the value of fix_root to a certain integer $k$ , the function only computes one generator for every conjugacy class of finite cyclic groups when computing the corresponding $\Phi_k$ -kernel sublattices;
if available, one can use any database of genera of definite lattices using the keyword argument genusDB (which should be a dictionary whose keys are genus symbols, and the corresponding value is a list of lattices of this genus);
if root_test is set to true, the genus enumeration algorithm determines whether any new genus of negative definite lattices to be enumerated consists only of lattices of maximum $-2$ . In such a case, the enumeration is skipped.

Examples

julia> L = root_lattice(:A, 2);

julia> Lf = integer_lattice_with_isometry(L);

julia> splitting_of_prime_power(Lf, 2)
4-element Vector{ZZLatWithIsom}:
 Integer lattice with isometry of finite order 2
 Integer lattice with isometry of finite order 2
 Integer lattice with isometry of finite order 2
 Integer lattice with isometry of finite order 1

julia> splitting_of_prime_power(Lf, 3, 1)
1-element Vector{ZZLatWithIsom}:
 Integer lattice with isometry of finite order 3

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

splitting_of_pure_mixed_prime_power — Method

splitting_of_pure_mixed_prime_power(
  Lf::ZZLatWithIsom,
  p::Int;
  eiglat_cond::Dict{Int, Vector{Int}}=Dict{Int, Vector{Int}}(),
  fix_root::Int=-1,
  genusDB::Union{Nothing, Dict{ZZGenus, Vector{ZZLat}}}=nothing,
  root_test::Bool=false,
) -> Vector{ZZLatWithIsom}

Given an even lattice with isometry $(L, f)$ with $f$ of order $m = p^d*q^e$ where $d > 0$ is positive, $e \geq 0$ is nonnegative and $q \neq p$ is a prime number distinct from $p$ , and such that $\prod_{i=0}^e\Phi_{p^dq^i}(f)$ is trivial, return a complete set of representatives for the isomorphism classes of lattices with isometry $(M, g)$ such that the type of $(M, g^p)$ is equal to the type of $(L, f)$ . Note that $e$ can be 0, while $d$ has to be positive.

For the advanced users

When using this function, one can use some extra keyword arguments which are carried along the computation:

by setting the value of fix_root to a certain integer $k$ , the function only computes one generator for every conjugacy class of finite cyclic groups when computing the corresponding $\Phi_k$ -kernel sublattices;
if available, one can use any database of genera of definite lattices using the keyword argument genusDB (which should be a dictionary whose keys are genus symbols, and the corresponding value is a list of lattices of this genus);
if root_test is set to true, the genus enumeration algorithm determines whether any new genus of negative definite lattices to be enumerated consists only of lattices of maximum $-2$ . In such a case, the enumeration is skipped.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

splitting_of_mixed_prime_power — Method

splitting_of_mixed_prime_power(
  Lf::ZZLatWithIsom,
  p::IntegerUnion,
  b::Int = 1;
  eiglat_cond::Dict{Int, Vector{Int}}=Dict{Int, Vector{Int}}(),
  fix_root::Int=-1,
  genusDB::Union{Nothing, Dict{ZZGenus, Vector{ZZLat}}}=nothing,
  root_test::Bool=false,
) -> Vector{ZZLatWithIsom}

Given an even lattice with isometry $(L, f)$ and a prime number $p$ such that $f$ has order $m=p^dq^e$ for some prime number $q \neq p$ , return a set of representatives of the isomorphism classes of lattices with isometry $(M, g)$ such that the type of $(M, g^p)$ is equal to the type of $(L, f)$ . Note that $d$ and $e$ can be both 0.

For the advanced users

When using this function, one can use some extra keyword arguments which are carried along the computation:

by setting the value of fix_root to a certain integer $k$ , the function only computes one generator for every conjugacy class of finite cyclic groups when computing the corresponding $\Phi_k$ -kernel sublattices;
if available, one can use any database of genera of definite lattices using the keyword argument genusDB (which should be a dictionary whose keys are genus symbols, and the corresponding value is a list of lattices of this genus);
if root_test is set to true, the genus enumeration algorithm determines whether any new genus of negative definite lattices to be enumerated consists only of lattices of maximum $-2$ . In such a case, the enumeration is skipped.

Examples

julia> L = root_lattice(:E, 7);

julia> f = matrix(QQ, 7, 7, [ 1  1  2  1  0  0  1;
                             -1 -2 -3 -2 -1 -1 -1;
                              0  1  2  1  1  1  1;
                              0  0 -1 -1 -1 -1 -1;
                              1  1  2  2  2  1  1;
                              0  0 -1 -1 -1  0  0;
                              0  0  0  1  0  0  0]);

julia> Lf = integer_lattice_with_isometry(L, f)
Integer lattice of rank 7 and degree 7
  with isometry of finite order 6
  given by
  [ 1    1    2    1    0    0    1]
  [-1   -2   -3   -2   -1   -1   -1]
  [ 0    1    2    1    1    1    1]
  [ 0    0   -1   -1   -1   -1   -1]
  [ 1    1    2    2    2    1    1]
  [ 0    0   -1   -1   -1    0    0]
  [ 0    0    0    1    0    0    0]

julia> reps = splitting_of_mixed_prime_power(Lf, 2)
2-element Vector{ZZLatWithIsom}:
 Integer lattice with isometry of finite order 12
 Integer lattice with isometry of finite order 12

julia> all(LL -> is_of_same_type(Lf, LL^2), reps)
true

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

splitting — Method

splitting(
  Lf::ZZLatWithIsom,
  p::Int,
  b::Int = 0;
  char_poly::Union{ZZPolyRingElem, QQPolyRingElem, Nothing}=nothing,
  min_poly::Union{ZZPolyRingElem, QQPolyRingElem, Nothing}=nothing,
  rks::Vector{Tuple{Int, Int}}=Tuple{Int, Int}[],
  pos_sigs::Vector{Tuple{Int, Int}}=Tuple{Int, Int}[],
  neg_sigs::Vector{Tuple{Int, Int}}=Tuple{Int, Int}[],
  eiglat_cond::Dict{Int64, Vector{Int64}}=Dict{Int64, Vector{Int64}}(),
  fix_root::Int=-1,
  genusDB::Union{Nothing, Dict{ZZGenus, Vector{ZZLat}}}=nothing,
  root_test::Bool=false,
) -> Vector{ZZLatWithIsom}

Given an even lattice with isometry $(L, f)$ where $f$ is of finite order $m$ , and given a prime number $p$ return a complete set of representatives for the isomorphism classes of lattices with isometry $(M, g)$ such that the type of $(M, g^p)$ is equal to the type of $(L, f)$ .

Warning

In the case where the order of the isometries in output has at most 2 prime divisors, we rely on the machinery of [BH23]. Otherwise, we use a naive approach which consists of decomposing $(L, f)$ into its irreducible eigenlattices, splitting each of them by p (using the function splitting_of_hermitian_type), and gluing back all blocks together.

For the advanced users

When using this function, one can use some extra keyword arguments which are carried along the computation:

by setting the value of fix_root to a certain integer $k$ , the function only computes one generator for every conjugacy class of finite cyclic groups when computing the corresponding $\Phi_k$ -kernel sublattices;
if available, one can use any database of genera of definite lattices using the keyword argument genusDB (which should be a dictionary whose keys are genus symbols, and the corresponding value is a list of lattices of this genus);
if root_test is set to true, the genus enumeration algorithm determines whether any new genus of negative definite lattices to be enumerated consists only of lattices of maximum $-2$ . In such a case, the enumeration is skipped.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

Note that an important feature from the theory in [BH23] is the notion of admissible gluings and equivariant primitive embeddings for admissible triples. In the next chapter, we present the methods regarding Nikulins's theory on primitive embeddings and their equivariant version. We use this basis to introduce the method admissible_equivariant_primitive_extensions (Algorithm 2 in [BH23]) which is the major tool making the previous enumeration possible and fast, from an algorithmic point of view.