gmodule(H::PermGroup, mR::MapRayClassGrp, mG = automorphism_group(PermGroup, Hecke.nf(order(codomain((mR)))))[2])

The natural ZZ[H] module where H, a subgroup of the automorphism group acts on the ray class group.

gmodule(R::ClassField, mG = automorphism_group(PermGroup, base_field(R))[2]; check::Bool = true)

The natural ZZ[G] module where G, the automorphism group, acts on the ideal group defining the class field.

gmodule(H::PermGroup, R::ClassField, mG = automorphism_group(PermGroup, k))

The natural ZZ[H] module where H, a subgroup of the automorphism group, acts on the ideal group defining the class field.

gmodule(K::Hecke.LocalField, k::Union{Hecke.LocalField, PadicField, QadicField} = base_field(K); Sylow::Int = 0, full::Bool = false)

For a local field extension K/k, return the multiplicative group of K as a Gal(K/k) module. Strictly, it returns a quotient of K^* that is cohomologically equivalent. For unramified fields, the quotient is just ZZ, for tame fields, it will be isomorphic to ZZ times F_q^* for the residue field F_q. In the wild case a suitable induced module is factored out.

Returns:

• the gmodule
• the map from G = Gal(K/k) -> Set of actual automorphisms
• the map from the module into K

gmodule(k::Field, C::GModule)

Rewrite the module over the field k.

gmodule(H::Union{Nothing, Oscar.GAPGroup}, ac::Vector{<:Map})

Given an automorphism of some module for each generator of the group H, return the ZZ[H] module.

Note: we do not check that this defined indeed a ZZ[H] module.

action(C::GModule, g, v::T) where T <: Array

For an array of objects in the module, compute the image under the action of g, ie. an array where each entry is mapped.

action(C::GModule, g, v)

The image of v under g

action(C::GModule, g)

The operation of g on the module as an automorphism.

induce(C::GModule{GT, MT}, h::Map, D = nothing, mDC = nothing) where GT <: GAPGroup where MT

For a Z[U]-Module C and a map U->G, compute the induced module: ind_U^G(C) = C otimes Z[G] where the tensor product is over Z[U]. The induced module is returned as a product of copies of C. it also returns

• the transversal used
• the projections
• the injections

If D and mDC are given then mDC: D -> C.M has to be a Z[U] linear homomorphism. I this case a Z[G] linear map to the induced module is returned.

cohomology_group(C::GModule, i::Int; Tate::Bool = false)

For a gmodule C compute the i-th cohomology group where i can be 0, 1 or 2. (or 3 ...) Together with the abstract module, a map is provided that will produce explicit cochains.

extension(::Type{FPGroup}, c::CoChain{2,<:Oscar.GAPGroupElem})

Given a 2-cocycle, return the corresponding group extension, ie. the large group, the injection of the abelian group and the quotient as well as a map that given a tuple of elements in the group and the abelian group returns the corresponding elt in the extension.

If the gmodule is defined via a pc-group and the 1st argument is the Type{PcGroup}, the resulting group is also pc.

extension_with_abelian_kernel(X::Oscar.GAPGroup, M::Oscar.GAPGroup)

For a group K and an abelian normal subgroup M, construct M as a X/M-modul amd find the 2-cochain representing X.

is_central(NtoE::Map) -> Bool

Tests if the domain is in the center of the codomain.

restriction_of_scalars(M::GModule, phi::Map)

Return the S-module obtained by restricting the scalars of M from R to S, where phi is an embedding of S into R.

If R has S-rank d and M has rank n then the returned module has rank d*n.

Examples

julia> G = dihedral_group(20);

julia> T = character_table(G);

julia> C = gmodule(T[8]);

julia> C = gmodule(CyclotomicField, C);

julia> h = subfields(base_ring(C), degree = 2)[1][2];

julia> restriction_of_scalars(C, h)
(G-module for G acting on vector space of dimension 4 over number field, Map: C -> g-module for G acting on vector space of dimension 4 over number field)

julia> restriction_of_scalars(C, QQ)
G-module for G acting on vector space of dimension 8 over QQ

trivial_gmodule(G::Group, M::FinGenAbGroup)
trivial_gmodule(G::Group, M::AbstractAlgebra.FPModule)

Return the G-module over the underlying set M with trivial G-action, i.e., g(m) == m for all $g\in G$ and $m\in M$.

regular_gmodule(G::GAPGroup, R::Ring)

Return (R[G], f, g), where

• R[G] is the group ring of G over R, as a G-module object,
• f is a function that, when applied to a G-module M over R, will return a function F representing the action of R[G] on M in the sense that for a vector x of length order(G) over R, F(x) is the module homomorphism on M induced by the action of the element of R[G] with coefficient vector x, and
• g is a bijective map between the elements of G and the indices of the corresponding module generators.

natural_gmodule(G::PermGroup, R::Ring)

Return the G-module of dimension degree(G) over R that is induced by the permutation action of G on the basis of the module.

natural_gmodule(G::MatrixGroup)

Return the G-module of dimension degree(G) over base_ring(G) that is induced by the action of G via right multiplication.

gmodule_minimal_field(C::GModule)
gmodule_minimal_field(k::Field, C::GModule)

Return TODO

gmodule_over(k::Field, C::GModule)

factor_set(C::GModule{<:Any, <:AbstractAlgebra.FPModule{AbsSimpleNumFieldElem}}, mA::Union{Map, Nothing} = nothing)

Compute the factor set or 2-cochain defined by C as a Galois module of the automorphism group over the character field. If mA is given, it needs to map the automorphism group over the character field into the the automorphisms of the base ring.

composition_factors_with_multiplicity(C::GModule{<:Any, <:AbstractAlgebra.FPModule{<:FinFieldElem}})

Return the composition factors of C with their frequency.

indecomposition(C::GModule{<:Any, <:AbstractAlgebra.FPModule{<:FinFieldElem}})

Return a decomposition of the module C into indecomposable summands as a list of pairs:

• a direct indecomposable summand
• a homomorphism (embedding) of the underlying free modules

ghom(C::GModule, D::GModule)

The G-module of all Z-module homomorphisms

units_mod_ideal(I::AbsSimpleNumFieldOrderIdeal; n_quo::Int = 0) -> FinGenAbGroup, Map{Grp, AbsSimpleNumFieldOrder}

Compute the unit group of the order modulo I. If n_quo is non-zero, the quotient modulo n_quo is computed.

is_coboundary(c::CoChain{2,PermGroupElem,MultGrpElem{AbsSimpleNumFieldElem}})

For a 2-cochain with values in the multiplicative group of a number field, decide if it is a coboundary (trivial in the Brauer group). If so also return a splitting 1-cochain.

decomposition_group(K::AbsSimpleNumField, mK::Map, mG::Map, mGp; _sub::Bool = false)

For a completion C of a number field K, implicitly given as the map mK: K -> C And the automorphism group G of K given via mG: G -> Aut(K) mG defaults to the full automorphism group of K as a permutation group. And the automorphism group Gp of Kp, given via mGp: Gp -> Aut(Kp) defaulting to the full automorphism group over the prime field.

Find the embedding of Gp -> G, realizing the local automorphism group as a subgroup of the global one.

decomposition_group(K::AbsSimpleNumField, emb::Hecke.NumFieldEmb, mG::Map)

For a real or complex embedding emb, find the unique automorphism that acts on this embedding as complex conjugation. mG, when given, should be the map from the automorphism group. Otherwise it will be automatically supplied.

idele_class_gmodule(k::AbsSimpleNumField, s::Vector{Int} = Int[])

Following Debeerst: Algorithms for Tamagawa Number Conjectures. Dissertation, University of Kassel, June 2011. or Ali,

Find a gmodule C s.th. C is cohomology-equivalent to the cohomology of the idele class group. The primes in s will always be used.

galois_group(A::ClassField, ::QQField; idele_parent::IdeleParent = idele_class_gmodule(base_field(A)))

Determine the Galois group (over QQ) of the extension parametrized by A. A needs to be normal over QQ.

Examples

julia> QQx, x = QQ[:x];

julia> k, a = number_field(x^4 - 12*x^3 + 36*x^2 - 36*x + 9);

julia> a = ray_class_field(8*3*maximal_order(k), n_quo = 2);

julia> a = filter(is_normal, subfields(a, degree = 2));

julia> I = idele_class_gmodule(k);

julia> b = [galois_group(x, QQ, idele_parent = I) for x = a];

julia> [describe(x[1]) for x = b]
3-element Vector{String}:
 "C4 x C2"
 "Q8"
 "D8"

relative_brauer_group(K::AbsSimpleNumField, k)

For k a subfield or QQ, create the relative Brauer group as an infinite direct sum of the local Brauer groups.

The second return value is a map translating between the local data and explicit 2-cochains.

julia> G = SL(2,5)
SL(2,5)

julia> T = character_table(G);

julia> R = gmodule(T[9])
G-module for G acting on vector space of dimension 6 over abelian closure of QQ

julia> S = gmodule(CyclotomicField, R)
G-module for G acting on vector space of dimension 6 over cyclotomic field of order 5

julia> B, mB = relative_brauer_group(base_ring(S), character_field(S));

julia> B
Relative Brauer group for cyclotomic field of order 5 over number field of degree 1 over QQ

julia> b = B(S)
Element of relative Brauer group of number field of degree 1 over QQ
  <2> -> 1//2 + Z
  <5> -> 0 + Z
  Real embedding of number field -> 1//2 + Z

brauer_group(K::AbsSimpleNumField)

The Brauer group as an infinite direct sum of the local Brauer groups.

The second return value is a map translating between the local data and explicit 2-cochains.

EXAMPLES

julia> k = rationals_as_number_field()[1];

julia> lp = collect(keys(factor(30*maximal_order(k))));

julia> qz = Hecke.QmodnZ();

julia> B, mB = brauer_group(k);

julia> b = B(Dict(lp[1]=>qz(1//3), lp[2]=>qz(2//3)));

julia> c = mB(b);

julia> C = structure_constant_algebra(c);

julia> Hecke.local_schur_indices(C);

julia> c = mB(b+b);

structure_constant_algebra(a::RelativeBrauerGroupElem)

Compute an explicit matrix algebra with the local invariants given by the element

structure_constant_algebra(CC::GrpCoh.CoChain{2, PermGroupElem, GrpCoh.MultGrpElem{AbsSimpleNumFieldElem}}, mG::Map = automorphism_group(PermGroup, CC.C.M.data)[2], mkK::Union{<:Map, Nothing} = nothing)

Return the cross-product algebra defined by the factor system given as a 2-cochain.