More hilbert_series

src/Modules/Modules.jl

@@ -1,4 +1,5 @@
 include("ModuleTypes.jl")
+include("hilbert.jl")
 include("UngradedModules.jl")
 include("homological-algebra.jl")
 include("FreeModElem-orderings.jl")

src/Modules/ModulesGraded.jl

@@ -572,7 +572,7 @@ function graded_map(F::FreeMod{T}, A::MatrixElem{T}) where {T <: RingElement}
   return phi
 end
 
-function graded_map(F::FreeMod{T}, V::Vector{<:FreeModElem{T}}) where {T <: RingElement}
+function graded_map(F::FreeMod{T}, V::Vector{<:AbstractFreeModElem{T}}) where {T <: RingElement}
   R = base_ring(F)
   G = grading_group(R)
   nrows = length(V)

src/Modules/hilbert.jl

@@ -0,0 +1,187 @@
+# This cannot be included in src/Rings/hilbert.jl because the include
+# order defined in src/Oscar.jl includes ring stuff before module stuff
+# (and it probably would not work if we inverted the inclusion order).
+
+# ==================================================================
+# Hilbert series numerator for modules
+
+function _power_product(T, expv)
+  return prod([T[k]^expv[k]  for k in 1:length(expv)]);
+end
+
+
+function HSNum_module(SubM::SubquoModule{T}, HSRing::Ring, backend::Symbol=:Abbott)  where T <: MPolyRingElem
+  C,phi = present_as_cokernel(SubM, :with_morphism);  # phi is the morphism
+  LM = leading_module(C.quo);
+  F = ambient_free_module(C.quo);
+  r = rank(F);
+  P = base_ring(C.quo);
+  # short-cut for module R^0 (to avoid problems with empty sum below)
+  if iszero(r)
+    return multi_hilbert_series(quo(P,ideal(P,[1]))[1]; parent=HSRing, backend=backend)[1][1]
+  end
+  GensLM = gens(LM);
+  L = [[] for _ in 1:r];  # L[k] will be list of monomial gens for k-th cooord
+  # Nested loop below extracts the coordinate monomial ideals -- is there a better way?
+  for g in GensLM
+    SR = coordinates(ambient_representative(g)); # should have length = 1
+    for j in 1:r
+      if SR[j] != 0
+        push!(L[j], SR[j]);
+      end
+    end
+  end
+  IdealList = [ideal(P,G)  for G in L];
+  HSeriesList = [multi_hilbert_series(quo(P,I)[1]; parent=HSRing, backend=backend)[1][1]  for I in IdealList];
+  shifts = [degree(phi(g))  for g in gens(F)];
+  @vprintln :hilbert 1 "HSNum_module: shifts are $(shifts)";
+  shift_expv = [gen_repr(d)  for d in shifts];
+  @vprintln :hilbert 1 "HSNum_module: shift_expv are $(shift_expv)";
+###  HSeriesRing = parent(HSeriesList[1]);
+###  @vprintln :hilbert 1 "HSNum_module: HSeriesRing = $(HSeriesRing)";
+  t = gens(HSRing);
+  ScaleFactor = [_power_product(t,e)  for e in shift_expv];
+  result = sum([ScaleFactor[k]*HSeriesList[k]  for k in 1:r]);
+  return result;
+end
+
+# No longer needed
+# function HSNum_module(F::FreeMod{T}; parent::Union{Nothing,Ring} = nothing)  where T <: MPolyRingElem
+#   # ASSUME F is graded free module
+#   return HSNum_module(sub(F,gens(F))[1]; parent=parent)
+# end
+
+@doc raw"""
+    multi_hilbert_series(M::SubquoModule; parent::Union{Nothing,Ring} = nothing)
+
+Compute a pair of pairs `(N ,D), (H ,iso)` where `N` and `D` are the non-reduced numerator and denominator of the Hilbert
+series of the subquotient `M`, and `H` is the SNF of the grading group together with the identifying isomorphism `iso`.
+If the kwarg `parent` is supplied `N` and `D` are computed in the ring `parent`.
+
+!!! note
+    CURRENT LIMITATION: the grading must be over ZZ^m (more general gradings are not yet supported)
+
+!!! note
+    Applied to a homogeneous subquotient `M`, the function first computes a Groebner basis to
+    obtain the leading term module; the rest of the computation uses this latter module
+    (sliced into ideals, one for each ambient free module component).
+
+# Examples
+```jldoctest
+julia> R, _ = polynomial_ring(QQ, ["x", "y", "z"]);
+
+julia> Rg, (x, y, z) = grade(R, [4,3,2]);
+
+julia> F = graded_free_module(Rg, 1);
+
+julia> A = Rg[x; y];
+
+julia> B = Rg[x^2; y^3; z^4];
+
+julia> M = SubquoModule(F, A, B);
+
+julia> (num,den),_ = multi_hilbert_series(M);
+
+julia> num
+-t^25 + 2*t^17 + t^16 + t^15 - t^12 - t^11 - t^9 - t^8 - t^7 + t^4 + t^3
+
+julia> den
+Factored element with data
+Dict{AbstractAlgebra.Generic.LaurentMPolyWrap{ZZRingElem, ZZMPolyRingElem, AbstractAlgebra.Generic.LaurentMPolyWrapRing{ZZRingElem, ZZMPolyRing}}, ZZRingElem}(-t^4 + 1 => 1, -t^3 + 1 => 1, -t^2 + 1 => 1)
+
+```
+"""
+function multi_hilbert_series(SubM::SubquoModule{T}; parent::Union{Nothing, Ring} = nothing, backend::Symbol = :Abbott)  where T <: MPolyRingElem
+  R = base_ring(SubM)
+  @req coefficient_ring(R) isa AbstractAlgebra.Field "The coefficient ring must be a field"
+
+  # Wrap the case where G is abstractly isomorphic to ℤᵐ, but not realized as a 
+  # free Abelian group. 
+  #
+  # We use the Smith normal form to get there, recreate the graded ring with the 
+  # free grading group, do the computation there and return the isomorphism for 
+  # the grading. 
+  G = grading_group(R)
+  if !is_zm_graded(R)
+    error("non-ZZ^m-grading not yet implemented for modules (see issue #2657)")  ### Needs improvement to change_base_ring (see below)
+    H, iso = snf(G)
+    V = [preimage(iso, x) for x in gens(G)]
+    isoinv = hom(G, H, V)
+    W = [isoinv(R.d[i]) for i = 1:ngens(R)]
+    S, _ = graded_polynomial_ring(coefficient_ring(R), symbols(R), W)
+    map_into_S = hom(R, S, gens(S))
+    SubM2,_ = change_base_ring(map_into_S,SubM) # !!! BUG this seems to forget that things are graded BUG (issue #2657) !!!
+    (numer, denom), _ = hilbert_series(SubM2; parent=parent, backend=backend)
+    return (numer, denom), (H, iso)
+  end
+
+  # Now we may assume that the grading group is free Abelian.
+  m = ngens(G)  
+  n = ngens(R)
+  HSRing = _hilbert_series_ring(parent, m)
+  # Get the weights as Int values: W[k] contains the weight(s) of x[k]
+  W = [[ Int(R.d[i][j])  for j in 1:m]  for i in 1:n]
+  denom = _hilbert_series_denominator(HSRing, W)
+  numer = HSNum_module(SubM, HSRing, backend)
+  return (numer, denom), (G, identity_map(G))
+end
+
+function multi_hilbert_series(F::FreeMod{T}; parent::Union{Nothing,Ring} = nothing, backend::Symbol = :Abbott)  where T <: MPolyRingElem
+  return multi_hilbert_series(sub(F,gens(F))[1]; parent=parent, backend=backend)
+end
+
+
+@doc raw"""
+    hilbert_series(M::SubquoModule; parent::Union{Nothing,Ring} = nothing)
+
+Compute a pair `(N,D)` where `N` and `D` are the non-reduced numerator and denominator of the Hilbert
+series of the subquotient `M`.  If the kwarg `parent` is supplied `N` and `D` are computed in the ring `parent`.
+
+!!! note
+    Applied to a homogeneous subquotient `M`, the function first computes a Groebner basis to
+    obtain the leading term module; the rest of the computation uses this latter module
+    (sliced into ideals, one for each ambient free module component).
+
+# Examples
+```jldoctest
+julia> R, _ = polynomial_ring(QQ, ["x", "y", "z"]);
+
+julia> Z = abelian_group(0);
+
+julia> Rg, (x, y, z) = grade(R, [Z[1],Z[1],Z[1]]);
+
+julia> F = graded_free_module(Rg, 1);
+
+julia> A = Rg[x; y];
+
+julia> B = Rg[x^2; y^3; z^4];
+
+julia> M = SubquoModule(F, A, B);
+
+julia> num,den = hilbert_series(M);
+
+julia> num
+-t^9 + t^7 + 2*t^6 - t^5 - t^3 - 2*t^2 + 2*t
+
+julia> den
+Factored element with data
+Dict{AbstractAlgebra.Generic.LaurentPolyWrap{ZZRingElem, ZZPolyRingElem, AbstractAlgebra.Generic.LaurentPolyWrapRing{ZZRingElem, ZZPolyRing}}, ZZRingElem}(-t + 1 => 3)
+
+```
+"""
+function hilbert_series(SubM::SubquoModule{T}; parent::Union{Nothing,Ring} = nothing, backend::Symbol = :Abbott)  where T <: MPolyRingElem
+  @req is_z_graded(base_ring(SubM)) "ring must be ZZ-graded; use `multi_hilbert_series` otherwise"
+  if parent === nothing
+    parent, _ = LaurentPolynomialRing(ZZ, :t)
+  end
+  HS, _ = multi_hilbert_series(SubM; parent=parent, backend=backend)
+  return HS
+end
+
+function hilbert_series(F::FreeMod{T}; parent::Union{Nothing,Ring} = nothing, backend::Symbol = :Abbott)  where T <: MPolyRingElem
+  @req is_z_graded(base_ring(F)) "ring must be ZZ-graded; use `multi_hilbert_series` otherwise"
+  if parent === nothing
+    parent, _ = LaurentPolynomialRing(ZZ, :t)
+  end
+  return hilbert_series(sub(F,gens(F))[1]; parent=parent, backend=backend)
+end

src/Oscar.jl

@@ -115,6 +115,8 @@ function __init__()
     add_verbose_scope(:Blowup)
     add_assert_scope(:Blowup)
 
+    add_verbose_scope(:hilbert)
+    add_assert_scope(:hilbert)
 
     add_verbose_scope(:GlobalTateModel)
     add_verbose_scope(:WeierstrassModel)

src/Rings/Rings.jl

@@ -3,6 +3,7 @@ include("orderings.jl")
 include("mpoly.jl")
 include("mpoly_types.jl")
 include("mpoly-graded.jl")
+include("hilbert_zach.jl")
 include("mpoly-ideals.jl")
 include("groebner.jl")
 include("solving.jl")
@@ -33,4 +34,5 @@ include("AlgClosureFp.jl")
 include("PBWAlgebra.jl")
 include("PBWAlgebraQuo.jl")
 include("FreeAssAlgIdeal.jl")
+include("hilbert.jl")