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 — Methodadmissible_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.
See also is_admissible_triple.
Examples
julia> L = root_lattice(:A, 5);
julia> g = genus(L)
Genus symbol for integer lattices
Signatures: (5, 0, 0)
Local symbols:
Local genus symbol at 2: 1^-4 2^1_7
Local genus symbol at 3: 1^-4 3^1
julia> admissible_triples(g, 5)
2-element Vector{Tuple{ZZGenus, ZZGenus}}:
(Genus symbol: II_(5, 0) 2^-1_3 3^1, Genus symbol: II_(0, 0))
(Genus symbol: II_(1, 0) 2^1_7 3^1 5^1, Genus symbol: II_(4, 0) 5^1)
julia> admissible_triples(g, 2)
8-element Vector{Tuple{ZZGenus, ZZGenus}}:
(Genus symbol: II_(5, 0) 2^-1_3 3^1, Genus symbol: II_(0, 0))
(Genus symbol: II_(4, 0) 2^2_6 3^1, Genus symbol: II_(1, 0) 2^1_1)
(Genus symbol: II_(3, 0) 2^-3_1 3^1, Genus symbol: II_(2, 0) 2^2_2)
(Genus symbol: II_(3, 0) 2^3_3, Genus symbol: II_(2, 0) 2^-2 3^1)
(Genus symbol: II_(2, 0) 2^-2 3^1, Genus symbol: II_(3, 0) 2^3_3)
(Genus symbol: II_(2, 0) 2^2_2, Genus symbol: II_(3, 0) 2^-3_1 3^1)
(Genus symbol: II_(1, 0) 2^1_1, Genus symbol: II_(4, 0) 2^2_6 3^1)
(Genus symbol: II_(0, 0), Genus symbol: II_(5, 0) 2^-1_3 3^1)This function is part of the experimental code in Oscar. Please read here for more details.
is_admissible_triple — Methodis_admissible_triple(
A::ZZGenus,
B::ZZGenus,
C::ZZGenus,
p::Int,
) -> BoolGiven a triple of $\mathbb Z$-genera $(A, B, C)$ and a prime number $p$, such that the rank of $B$ is divisible by $p-1$, return whether $(A, B, C)$ is $p$-admissible.
See Lemma 4.15. in [BH23] for a definition of $p$-admissible.
Examples
A standard example is the following: let $(L, f)$ be a lattice with isometry of prime order $p$, let $F:= L^f$ and $C:= L_f$ be respectively the invariant and coinvariant sublattices of $(L, f)$. Then, the triple of genera $(g(F), g(C), g(L))$ is $p$-admissible.
julia> L = root_lattice(:A, 5);
julia> f = matrix(QQ, 5, 5, [1 1 1 1 1;
0 -1 -1 -1 -1;
0 1 0 0 0;
0 0 1 0 0;
0 0 0 1 0]);
julia> multiplicative_order(f)
5
julia> Lf = integer_lattice_with_isometry(L, f);
julia> F = invariant_lattice(Lf);
julia> C = coinvariant_lattice(Lf);
julia> is_admissible_triple(genus(F), genus(C), genus(Lf), 5)
trueThis function is part of the experimental code in Oscar. Please read here for more details.
Note that admissible triples are mainly used for enumerating lattices with isometry of a given order and in a given genus.
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 — Methodrepresentatives_of_hermitian_type(
G::Union{ZZGenus, ZZLat},
chi::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 $chi$ 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 $chi$.
One can also provide a representative $L$ of $G$ instead.
The value $n$ of fix_root matters only when $chi$ is cyclotomic. In the case where $chi$ 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 $chi$.
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.
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
condto 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_testis 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])
trueThis function is part of the experimental code in Oscar. Please read here for more details.
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 — Methodrepresentatives_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.
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
condto 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_testis 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])
trueThis function is part of the experimental code in Oscar. Please read here for more details.
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 — Methodenumerate_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.
When using this function, one can use some extra keyword arguments which are carried along the computation:
- by setting the value of
fix_rootto 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_testis 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_resulttotrue, 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]))
0This function is part of the experimental code in Oscar. Please read here for more details.
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 — Methodrepresentatives_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).
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
condto 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_testis 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])
trueThis function is part of the experimental code in Oscar. Please read here for more details.
splitting_of_hermitian_type — Methodsplitting_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.
When using this function, one can use some extra keyword arguments which are carried along the computation:
- by setting the value of
fix_rootto 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_testis 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)
trueThis function is part of the experimental code in Oscar. Please read here for more details.
splitting_of_prime_power — Methodsplitting_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.
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 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.
When using this function, one can use some extra keyword arguments which are carried along the computation:
- by setting the value of
fix_rootto 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_testis 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 3This function is part of the experimental code in Oscar. Please read here for more details.
splitting_of_pure_mixed_prime_power — Methodsplitting_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 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.
When using this function, one can use some extra keyword arguments which are carried along the computation:
- by setting the value of
fix_rootto 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_testis 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.
This function is part of the experimental code in Oscar. Please read here for more details.
splitting_of_mixed_prime_power — Methodsplitting_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.
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 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.
When using this function, one can use some extra keyword arguments which are carried along the computation:
- by setting the value of
fix_rootto 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_testis 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)
trueThis function is part of the experimental code in Oscar. Please read here for more details.
splitting — Methodsplitting(
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)$.
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 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.
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.
When using this function, one can use some extra keyword arguments which are carried along the computation:
- by setting the value of
fix_rootto 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_testis 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.
This function is part of the experimental code in Oscar. Please read here for more details.
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.