move code from Oscar.jl/experimental/GModule/Misc.jl here

src/GrpAb/Elem.jl

@@ -100,7 +100,7 @@
 gens(G::FinGenAbGroup) = FinGenAbGroupElem[G[i] for i = 1:ngens(G)]
 
 @doc raw"""
-    gen(G::FinGenAbGroup, i::Int) -> Vector{FinGenAbGroupElem}
+    gen(G::FinGenAbGroup, i::Int) -> FinGenAbGroupElem
 
 The $i$-th generator of $G$.
 """
@@ -293,6 +293,12 @@
   return z
 end
 
+function (A::FinGenAbGroup)(x::FinGenAbGroupElem)
+  fl, m = is_subgroup(parent(x), A)
+  @assert fl
+  return m(x)
+end
+
 function (A::FinGenAbGroup)()
   y = zero_matrix(FlintZZ, 1, ngens(A))
   z = FinGenAbGroupElem(A, y)

src/GrpAb/GrpAbFinGen.jl

@@ -84,6 +84,36 @@
   return abelian_group(FinGenAbGroup, M, name=name)
 end
 
+function abelian_group(M::Generic.FreeModule{ZZRingElem})
+  A = free_abelian_group(rank(M))
+  return A, MapFromFunc(A, M, x->M(x.coeff), y->A(y.v))
+end
+
+#TODO: for modern fin. fields as well
+function abelian_group(M::AbstractAlgebra.FPModule{fqPolyRepFieldElem})
+  k = base_ring(M)
+  A = abelian_group([characteristic(k) for i = 1:dim(M)*degree(k)])
+  n = degree(k)
+  function to_A(m::AbstractAlgebra.FPModuleElem{fqPolyRepFieldElem})
+    a = ZZRingElem[]
+    for i=1:dim(M)
+      c = m[i]
+      for j=0:n-1
+        push!(a, coeff(c, j))
+      end
+    end
+    return A(a)
+  end
+  function to_M(a::FinGenAbGroupElem)
+    m = fqPolyRepFieldElem[]
+    for i=1:dim(M)
+      push!(m, k([a[j] for j=(i-1)*n+1:i*n]))
+    end
+    return M(m)
+  end
+  return A, MapFromFunc(A, M, to_M, to_A)
+end
+
 function abelian_group(::Type{FinGenAbGroup}, M::AbstractMatrix{<:IntegerUnion}; name::String = "")
   return abelian_group(matrix(FlintZZ, M), name=name)
 end
@@ -662,6 +692,27 @@
   return _direct_product(:sum, G...; task = task, kwargs...)
 end
 
+@doc raw"""
+    direct_sum(G::FinGenAbGroup, H::FinGenAbGroup, V::Vector{<:Map{FinGenAbGroup, FinGenAbGroup}})
+
+For groups `G = prod G_i` and `H = prod H_i` as well as maps `V_i: G_i -> H_i`,
+build the induced map from `G -> H`.
+"""
+function direct_sum(G::FinGenAbGroup, H::FinGenAbGroup, V::Vector{<:Map{FinGenAbGroup, FinGenAbGroup}})
+  dG = get_attribute(G, :direct_product)
+  dH = get_attribute(H, :direct_product)
+
+  if dG === nothing || dH === nothing
+    error("both groups need to be direct products")
+  end
+  @assert length(V) == length(dG) == length(dH)
+
+  @assert all(i -> domain(V[i]) == dG[i] && codomain(V[i]) == dH[i], 1:length(V))
+  h = hom(G, H, cat([matrix(V[i]) for i=1:length(V)]..., dims=(1,2)), check = !true)
+  return h
+end
+
+
 @doc raw"""
     direct_product(G::FinGenAbGroup...) -> FinGenAbGroup, Vector{FinGenAbGroupHom}
 
@@ -839,6 +890,13 @@
   return identity_matrix(FlintZZ, ngens(domain(M)))
 end
 
+function dual(h::Map{FinGenAbGroup, FinGenAbGroup})
+  A = domain(h)
+  B = codomain(h)
+  @assert is_free(A) && is_free(B)
+  return hom(B, A, transpose(h.map))
+end
+
 @doc raw"""
     hom(G::FinGenAbGroup, H::FinGenAbGroup, A::Matrix{ <: Map{FinGenAbGroup, FinGenAbGroup}}) -> Map
 
@@ -1506,6 +1564,7 @@
 
 #checks if the image of mG contains the image of mH
 
+is_sub_with_data(M::FinGenAbGroup, N::FinGenAbGroup) = is_subgroup(M, N)
 
 #cannot define == as this produces problems elsewhere... need some thought
 function is_eq(G::FinGenAbGroup, H::FinGenAbGroup, L::GrpAbLattice = GroupLattice)

src/GrpAb/Map.jl

@@ -342,6 +342,9 @@
   return quo(codomain(h), FinGenAbGroupElem[mS(g) for g in gens(S)], add_to_lattice)
 end
 
+cokernel(h::Map) = quo(codomain(h), image(h)[1])
+
+
 ################################################################################
 #
 #  Surjectivity

src/LocalField/map.jl

@@ -29,6 +29,8 @@
   end
 end
 
+parent(f::LocalFieldMor) = NfMorSet(domain(f))
+
 ################################################################################
 #
 #   Identity

src/Map/Map.jl

@@ -18,6 +18,10 @@
   return InverseMap(a)
 end
 
+function pseudo_inv(h::Generic.ModuleHomomorphism)
+  return MapFromFunc(codomain(h), domain(h), x -> preimage(h, x))
+end
+
 #function show(io::IO, M::CoerceMap)
 #  println(io, "Coerce: $(domain(M)) -> $(codomain(M))")
 #end

src/Map/NumberField.jl

@@ -6,6 +6,8 @@
   return morphism_type(T, T)
 end
 
+elem_type(::Type{NfMorSet{T}}) where {T <: LocalField} = LocalFieldMor{T, T}
+
 function show(io::IO, S::NfMorSet{T}) where {T}
   print(io, "Set of automorphisms of ", S.field)
 end

src/Misc/Fields.jl

@@ -177,3 +177,37 @@
   return dot(f.B, (f.L).(map(f.f, v)))::elem_type(f.L)
 end
 
+#XXX: have a type for an implicit field - in Hecke?
+#     add all(?) the other functions to it
+function relative_field(m::Map{<:AbstractAlgebra.Field, <:AbstractAlgebra.Field})
+  k = domain(m)
+  K = codomain(m)
+  @assert base_field(k) == base_field(K)
+  kt, t = polynomial_ring(k, cached = false)
+  f = defining_polynomial(K)
+  Qt = parent(f)
+  #the Trager construction, works for extensions of the same field given
+  #via primitive elements
+  h = gcd(gen(k) - map_coefficients(k, Qt(m(gen(k))), parent = kt), map_coefficients(k, f, parent = kt))
+  coordinates = function(x::FieldElem)
+    @assert parent(x) == K
+    c = collect(Hecke.coefficients(map_coefficients(k, Qt(x), parent = kt) % h))
+    c = vcat(c, zeros(k, degree(h)-length(c)))
+    return c
+  end
+  rep_mat = function(x::FieldElem)
+    @assert parent(x) == K
+    c = map_coefficients(k, Qt(x), parent = kt) % h
+    m = collect(Hecke.coefficients(c))
+    m = vcat(m, zeros(k, degree(h) - length(m)))
+    r = m
+    for i in 2:degree(h)
+      c = shift_left(c, 1) % h
+      m = collect(Hecke.coefficients(c))
+      m = vcat(m, zeros(k, degree(h) - length(m)))
+      r = hcat(r, m)
+    end
+    return transpose(matrix(r))
+  end
+  return h, coordinates, rep_mat
+end

src/Misc/RatRecon.jl

@@ -110,6 +110,18 @@
   return fl!=0, numerator(res), denominator(res)
 end
 
+function induce_rational_reconstruction(a::ZZMatrix, pg::ZZRingElem; ErrorTolerant::Bool = false)
+  c = zero_matrix(QQ, nrows(a), ncols(a))
+  for i=1:nrows(a)
+    for j=1:ncols(a)
+      fl, n, d = rational_reconstruction(a[i,j], pg, ErrorTolerant = ErrorTolerant)
+      fl || return fl, c
+      c[i,j] = n//d
+    end
+  end
+  return true, c
+end
+
 #Note: the vector version might be useful - or the mult by previous den version
 #Note: missing reconstruction modulo a true ideal. W/o denominators
 
@@ -137,6 +149,17 @@
   return true, K(res)
 end
 
+function induce_rational_reconstruction(a::Generic.MatSpaceElem{AbsSimpleNumFieldElem}, pg::ZZRingElem; ErrorTolerant::Bool = false)
+  c = parent(a)()
+  for i=1:nrows(a)
+    for j=1:ncols(a)
+      fl, c[i,j] = rational_reconstruction(a[i,j], pg)#, ErrorTolerant = ErrorTolerant)
+      fl || return fl, c
+    end
+  end
+  return true, c
+end
+
 # to appease the Singular crowd...
 farey_lift = rational_reconstruction
 

src/NumField/ComplexEmbeddings/Generic.jl

@@ -157,6 +157,8 @@
 """
 restrict(f::NumFieldEmb, K::NumFieldHom)
 
+restrict(::Hecke.NumFieldEmb, ::Map{QQField, AbsSimpleNumField}) = complex_embeddings(QQ)[1]
+
 ################################################################################
 #
 #  Extension

src/NumField/ComplexEmbeddings/QQ.jl

@@ -25,6 +25,8 @@
 
 is_real(::QQEmb) = true
 
+extend(::QQEmb, mp::MapFromFunc{QQField, AbsSimpleNumField}) = complex_embeddings(codomain(mp))
+
 restrict(::NumFieldEmb, ::QQField) = QQEmb()
 
 restrict(e::NumFieldEmb, f::NumFieldHom{QQField}) = QQEmb()

src/NumField/NfAbs/Elem.jl

@@ -231,6 +231,21 @@
   return c
 end
 
+function induce_crt(a::Generic.MatSpaceElem{AbsSimpleNumFieldElem}, b::Generic.MatSpaceElem{AbsSimpleNumFieldElem}, p::ZZRingElem, q::ZZRingElem)
+  c = parent(a)()
+  pi = invmod(p, q)
+  mul!(pi, pi, p)
+  pq = p*q
+  z = ZZRingElem(0)
+
+  for i=1:nrows(a)
+    for j=1:ncols(a)
+      c[i,j] = induce_inner_crt(a[i,j], b[i,j], pi, pq, z)
+    end
+  end
+  return c
+end
+
 ################################################################################
 #
 #  Norm

src/NumFieldOrd/NfOrd/Ideal/Relative.jl

@@ -97,6 +97,7 @@
   return minimum(m, numerator(I))//denominator(I)
 end
 
+Base.minimum(::Map{QQField, AbsSimpleNumField}, I::Union{Hecke.AbsNumFieldOrderIdeal, Hecke.AbsNumFieldOrderFractionalIdeal}) = minimum(I)*ZZ
 
 ################################################################################
 #

src/QuadForm/Spaces.jl

@@ -21,6 +21,26 @@
   return AbstractSpaceMor(V, W, B)
 end
 
+function hom(F::AbstractAlgebra.FPModule{T}, G::AbstractAlgebra.FPModule{T}) where T
+  k = base_ring(F)
+  @assert base_ring(G) == k
+  H = free_module(k, dim(F)*dim(G))
+  return H, MapFromFunc(H, Hecke.MapParent(F, G, "homomorphisms"), x->hom(F, G, matrix(k, dim(F), dim(G), vec(collect(x.v)))), y->H(vec(collect(transpose(matrix(y))))))
+end
+
+function id_hom(A::AbstractAlgebra.FPModule)
+  return Generic.ModuleHomomorphism(A, A, identity_matrix(base_ring(A), ngens(A)))
+end
+
+function dual(h::Map{<:AbstractAlgebra.FPModule{ZZRingElem}, <:AbstractAlgebra.FPModule{ZZRingElem}})
+  A = domain(h)
+  B = codomain(h)
+  @assert is_free(A) && is_free(B)
+  return hom(B, A, transpose(matrix(h)))
+end
+
+parent(H::AbstractAlgebra.Generic.ModuleHomomorphism{<:FieldElem}) = Hecke.MapParent(domain(H), codomain(H), "homomorphisms")
+
 matrix(f::AbstractSpaceMor) = f.matrix
 
 function image(f::AbstractSpaceMor, v::Vector)
@@ -755,6 +775,20 @@
 
 direct_product(x::Vararg{AbstractSpace}) = direct_product(collect(x))
 
+function direct_product(M::AbstractAlgebra.Module...; task::Symbol = :none)
+  D, inj, pro = direct_sum(M...)
+  if task == :none
+    return D
+  elseif task == :both
+    return D, pro, inj
+  elseif task == :sum
+    return D, inj
+  elseif task == :prod
+    return D, pro
+  end
+  error("illegal task")
+end
+
 @doc raw"""
     biproduct(x::Vararg{T}) where T <: AbstractSpace -> T, Vector{AbstractSpaceMor}, Vector{AbstractSpaceMor}
     biproduct(x::Vector{T}) where T <: AbstractSpace -> T, Vector{AbstractSpaceMor}, Vector{AbstractSpaceMor}

src/exports.jl

@@ -783,6 +783,7 @@ export reduction_type
 export refine_alpha_bound
 export regulator
 export relations
+export relative_field
 export relative_residue_field
 export relative_simple_extension
 export rels