Structural Computations

Structural Computations

Abelian groups support a wide range of structural operations such as

• enumeration of subgroups
• (outer) direct products
• tensor and hom constructions
• free resolutions and general complexes
• (co)-homology and tensor and hom-functors

# snf — Method.

snf(A::GrpAbFinGen) -> GrpAbFinGen, GrpAbFinGenMap

Returns a pair $(G, f)$, where $G$ is an abelian group in canonical Smith normal form isomorphic to $A$ and an isomorphism $f : G \to A$.

source

# find_isomorphism — Method.

find_isomorphism(G, op, A::GrpAb) -> Dict, Dict

Given an abelian group $A$ and a collection $G$ which is an abelian group with the operation op, this functions returns isomorphisms $G \to A$ and $A \to G$ encoded as dictionaries.

It is assumed that $G$ and $A$ are isomorphic.

source

Subgroups and Quotients

# torsion_subgroup — Method.

torsion_subgroup(G::GrpAbFinGen) -> GrpAbFinGen, Map

Returns the torsion subgroup of G.

source

# sub — Method.

sub(G::GrpAbFinGen, s::Vector{GrpAbFinGenElem}) -> GrpAbFinGen, Map

Create the subgroup $H$ of $G$ generated by the elements in s together with the injection $\iota : H \to G$.

source

# sub — Method.

sub(s::Vector{GrpAbFinGenElem}) -> GrpAbFinGen, Map

Assuming that the non-empty array s contains elements of an abelian group $G$, this functions returns the subgroup $H$ of $G$ generated by the elements in s together with the injection $\iota : H \to G$.

source

sub(A::SMat, r::UnitRange, c::UnitRange) -> SMat

Return the submatrix of $A$, where the rows correspond to $r$ and the columns correspond to $c$.

source

# sub — Method.

sub(G::GrpAbFinGen, M::fmpz_mat) -> GrpAbFinGen, Map

Create the subgroup $H$ of $G$ generated by the elements corresponding to the rows of $M$ together with the injection $\iota : H \to G$.

source

# sub — Method.

sub(G::GrpAbFinGen, n::fmpz) -> GrpAbFinGen, Map

Create the subgroup $n \cdot G$ of $G$ together with the injection $\iota : n\cdot G \to G$.

source

# sub — Method.

sub(G::GrpAbFinGen, n::Integer) -> GrpAbFinGen, Map

Create the subgroup $n \cdot G$ of $G$ together with the injection $\iota : n \cdot G \to G$.

source

# psylow_subgroup — Method.

psylow_subgroup(G::GrpAbFinGen, p::IntegerUnion) -> GrpAbFinGen, Map

Returns the $p$-Sylow subgroup of G.

source

# has_quotient — Method.

has_quotient(G::GrpAbFinGen, invariant::Vector{Int}) -> Bool

Given an abelian group $G$, returns true if it has a quotient with given elementary divisors and false otherwise.

source

# has_complement — Method.

has_complement(f::GrpAbFinGenMap) -> Bool, GrpAbFinGenMap
has_complement(U::GrpAbFinGen, G::GrpAbFinGen) -> Bool, GrpAbFinGen

Given a map representing a subgroup of a group $G$, or a subgroup U of a group G, returns either true and an injection of a complement in $G$, or false.

See also: is_pure

source

# is_pure — Method.

is_pure(U::GrpAbFinGen, G::GrpAbFinGen) -> Bool

A subgroup U of G is called pure iff for all n an element in U that is in the image of the multiplication by n map of G is also a multiple of an element in U.

For finite abelian groups this is equivalent to U having a complement in G. They are also know as isolated subgroups and serving subgroups.

See also: is_neat, has_complement

EXAMPLES

julia> G = abelian_group([2, 8]);

julia> U, _ = sub(G, [G[1]+2*G[2]]);

julia> is_pure(U, G)
false

julia> U, _ = sub(G, [G[1]+4*G[2]]);

julia> is_pure(U)
true

julia> has_complement(U, G)[1]
true

source

# is_neat — Method.

is_neat(U::GrpAbFinGen, G::GrpAbFinGen) -> Bool

A subgroup U of G is called neat iff for all primes p an element in U that is in the image of the multiplication by p map of G is also a multiple of an element in U.

See also: is_pure

EXAMPLES

julia> G = abelian_group([2, 8]);

julia> U, _ = sub(G, [G[1] + 2*G[2]]);

julia> is_neat(U, G)
true

julia> is_pure(U, G)
false

source

# saturate — Method.

saturate(U::GrpAbFinGen, G::GrpAbFinGen) -> GrpAbFinGen

For a subgroup U of G find a minimal overgroup that is pure, and thus has a complement.

See also: is_pure, has_complement

source

A sophisticated algorithm for the enumeration of all (or selected) subgroups of a finite abelian group is available.

# psubgroups — Method.

psubgroups(g::GrpAbFinGen, p::Integer;
           subtype = :all,
           quotype = :all,
           index = -1,
           order = -1)

Return an iterator for the subgroups of $G$ of the specific form. Note that subtype (and quotype) is the type of the subgroup as an abelian $p$-group.

source

julia> G = abelian_group([6, 12])
GrpAb: Z/6 x Z/12

julia> shapes = MSet{Vector{fmpz}}()
MSet{Vector{fmpz}}()

julia> for U = psubgroups(G, 2)
         push!(shapes, elementary_divisors(U[1]))
       end


julia> shapes
MSet(fmpz[4] : 2, fmpz[1], fmpz[2, 4], fmpz[2] : 3, fmpz[2, 2])

So there are $2$ subgroups isomorphic to $C_4$ (fmpz[4] : 2), $1$ isomorphic to $C_2\times C_4$, 1 trivial and $3$ $C_2$ subgroups.

# subgroups — Method.

subgroups(g::GrpAbFinGen;
          subtype = :all ,
          quotype = :all,
          index = -1,
          order = -1)

Return an iterator for the subgroups of $G$ of the specific form.

source

julia> for U = subgroups(G, subtype = [2])
         @show U[1], map(U[2], gens(U[1]))
       end
(U[1], map(U[2], gens(U[1]))) = (GrpAb: Z/2, GrpAbFinGenElem[Element of
GrpAb: Z/6 x Z/12
with components [0 6]])
(U[1], map(U[2], gens(U[1]))) = (GrpAb: Z/2, GrpAbFinGenElem[Element of
GrpAb: Z/6 x Z/12
with components [3 6]])
(U[1], map(U[2], gens(U[1]))) = (GrpAb: Z/2, GrpAbFinGenElem[Element of
GrpAb: Z/6 x Z/12
with components [3 0]])

julia> for U = subgroups(G, quotype = [2])
         @show U[1], map(U[2], gens(U[1]))
       end
(U[1], map(U[2], gens(U[1]))) = ((General) abelian group with relation matrix
[4 0 0; 0 3 0; 0 0 3], GrpAbFinGenElem[Element of
GrpAb: Z/6 x Z/12
with components [3 3], Element of
GrpAb: Z/6 x Z/12
with components [0 4], Element of
GrpAb: Z/6 x Z/12
with components [2 0]])
(U[1], map(U[2], gens(U[1]))) = ((General) abelian group with relation matrix
[4 0 0; 0 3 0; 0 0 3], GrpAbFinGenElem[Element of
GrpAb: Z/6 x Z/12
with components [0 3], Element of
GrpAb: Z/6 x Z/12
with components [0 4], Element of
GrpAb: Z/6 x Z/12
with components [2 0]])
(U[1], map(U[2], gens(U[1]))) = ((General) abelian group with relation matrix
[2 0 0 0; 0 2 0 0; 0 0 3 0; 0 0 0 3], GrpAbFinGenElem[Element of
GrpAb: Z/6 x Z/12
with components [3 6], Element of
GrpAb: Z/6 x Z/12
with components [0 6], Element of
GrpAb: Z/6 x Z/12
with components [0 4], Element of
GrpAb: Z/6 x Z/12
with components [2 0]])

# quo — Method.

quo(G::GrpAbFinGen, s::Vector{GrpAbFinGenElem}) -> GrpAbFinGen, Map

Create the quotient $H$ of $G$ by the subgroup generated by the elements in $s$, together with the projection $p : G \to H$.

source

# quo — Method.

quo(G::GrpAbFinGen, M::fmpz_mat) -> GrpAbFinGen, Map

Create the quotient $H$ of $G$ by the subgroup generated by the elements corresponding to the rows of $M$, together with the projection $p : G \to H$.

source

# quo — Method.

quo(G::GrpAbFinGen, n::Integer}) -> GrpAbFinGen, Map
quo(G::GrpAbFinGen, n::fmpz}) -> GrpAbFinGen, Map

Returns the quotient $H = G/nG$ together with the projection $p : G \to H$.

source

# quo — Method.

quo(G::GrpAbFinGen, n::Integer}) -> GrpAbFinGen, Map
quo(G::GrpAbFinGen, n::fmpz}) -> GrpAbFinGen, Map

Returns the quotient $H = G/nG$ together with the projection $p : G \to H$.

source

# quo — Method.

quo(G::GrpAbFinGen, U::GrpAbFinGen) -> GrpAbFinGen, Map

Create the quotient $H$ of $G$ by $U$, together with the projection $p : G \to H$.

source

For 2 subgroups U and V of the same group G, U+V returns the smallest subgroup of G containing both. Similarly, $U\cap V$ computes the intersection and U \subset V tests for inclusion. The difference between issubset = $\subset$ and is_subgroup is that the inclusion map is also returned in the 2nd call.

# intersect — Method.

intersect(mG::GrpAbFinGenMap, mH::GrpAbFinGenMap) -> GrpAbFinGen, Map

Given two injective maps of abelian groups with the same codomain $G$, return the intersection of the images as a subgroup of $G$.

source

Direct Products

# direct_product — Method.

direct_product(G::GrpAbFinGen...; task::Symbol = :prod) -> GrpAbFinGen, GrpAbFinGenMap, GrpAbFinGenMap

Returns the direct product $D$ of the abelian groups $G_i$. task can be ":sum", ":prod", ":both" or ":none" and determines which canonical maps are computed as well: ":sum" for the injections, ":prod" for the projections.

source

# canonical_injection — Method.

canonical_injection(G::GrpAbFinGen, i::Int) -> Map

Given a group $G$ that was created as a direct product, return the injection from the $i$th component.

source

# canonical_projection — Method.

canonical_projection(G::GrpAbFinGen, i::Int) -> Map

Given a group $G$ that was created as a direct product, return the projection onto the $i$th component.

source

# flat — Method.

flat(G::GrpAbFinGen) -> GrpAbFinGen, Map

Given a group $G$ that is created using (iterated) direct products, or (iterated) tensor product, return a group that is a flat product: $(A \oplus B) \oplus C$ is returned as $A \oplus B \oplus C$, (resp. $\otimes$) together with the isomorphism.

source

Tensor Producs

# tensor_product — Method.

tensor_product(G::GrpAbFinGen...; task::Symbol = :map) -> GrpAbFinGen, Map

Given groups $G_i$, compute the tensor product $G_1\otimes \cdots \otimes G_n$. If task is set to ":map", a map $\phi$ is returned that maps tuples in $G_1 \times \cdots \times G_n$ to pure tensors $g_1 \otimes \cdots \otimes g_n$. The map admits a preimage as well.

source

<a id='hom-Tuple{GrpAbFinGen, GrpAbFinGen, Vector{<:Map{GrpAbFinGen, GrpAbFinGen}}}' href='#hom-Tuple{GrpAbFinGen, GrpAbFinGen, Vector{<:Map{GrpAbFinGen, GrpAbFinGen}}}'># hom — Method.

hom(G::GrpAbFinGen, H::GrpAbFinGen, A::Vector{ <: Map{GrpAbFinGen, GrpAbFinGen}}) -> Map

Given groups $G = G_1 \otimes \cdots \otimes G_n$ and $H = H_1 \otimes \cdot \otimes H_n$ as well as maps $\phi_i: G_i\to H_i$, compute the tensor product of the maps.

source

Hom-Group

# hom — Method.

hom(G::GrpAbFinGen, H::GrpAbFinGen; task::Symbol = :map) -> GrpAbFinGen, Map

Computes the group of all homomorpisms from $G$ to $H$ as an abstract group. If task is ":map", then a map $\phi$ is computed that can be used to obtain actual homomorphisms. This map also allows preimages. Set task to ":none" to not compute the map.

source