Add support for spectral sequences in Cech cohomology

experimental/DoubleAndHyperComplexes/src/DoubleAndHyperComplexes.jl

@@ -29,6 +29,14 @@ include("Morphisms/methods.jl")
 include("Objects/Methods.jl")
 include("Exports.jl")
 
+include("Morphisms/new_koszul_complexes.jl")
+include("Morphisms/induced_homs.jl")
+include("Morphisms/tensor_product.jl")
+include("Morphisms/shifted_complexes.jl")
+include("Morphisms/views.jl")
+include("Morphisms/total_complexes.jl")
+include("Morphisms/strand_morphisms.jl")
+include("Morphisms/SummandProjection.jl")
 include("base_change_types.jl")
 include("base_change.jl")
 

experimental/DoubleAndHyperComplexes/src/Morphisms/SummandProjection.jl

@@ -0,0 +1,77 @@
+#= 
+# Say you have an injective morphism of complexes `ι : C* ↪ D*` of `FreeMod`ules where 
+#
+#   ιᵏ : Cᵏ ≅ Rᵐ ↪ Rⁿ ≅ Dᵏ
+#
+# takes the generators of Cᵏ to a subset of the generators of Dᵏ for each k. 
+# Then Rⁿ ≅ Rᵐ ⊕ Rⁿ⁻ᵐ decomposes as a direct sum. This type of morphism 
+# computes the corresponding projection `π : D* → C*`. 
+=#
+
+struct SummandProjectionFactory{MorphismType} <: HyperComplexMorphismFactory{MorphismType}
+  inc::AbsHyperComplexMorphism
+  check::Bool
+
+  function SummandProjectionFactory(
+      inc::AbsHyperComplexMorphism{DomainType, CodomainType, MorphismType};
+      check::Bool=true
+    ) where {DomainType, CodomainType, MorphismType}
+    return new{MorphismType}(inc, check)
+  end
+end
+
+@attributes mutable struct SummandProjection{DomainType, CodomainType, MorphismType} <: AbsHyperComplexMorphism{DomainType, CodomainType, MorphismType, SummandProjection{DomainType, CodomainType, MorphismType}}
+  internal_morphism::HyperComplexMorphism{DomainType, CodomainType, MorphismType}
+
+  function SummandProjection(
+      inc::AbsHyperComplexMorphism{DomainType, CodomainType, MorphismType};
+      check::Bool=true
+    ) where {DomainType, CodomainType, MorphismType}
+    map_factory = SummandProjectionFactory(inc; check)
+
+    internal_morphism = HyperComplexMorphism(
+                                             codomain(inc), domain(inc), 
+                                             map_factory, cached=true, 
+                                             offset=-offset(inc)
+                                            )
+    return new{CodomainType, DomainType, MorphismType}(internal_morphism)
+  end
+end
+
+function (fac::SummandProjectionFactory)(self::AbsHyperComplexMorphism, i::Tuple)
+  inc = fac.inc[i]
+  dom = domain(inc)::FreeMod
+  cod = codomain(inc)::FreeMod
+  img_gens = elem_type(dom)[]
+  img_gens_inc = images_of_generators(inc)
+  if fac.check
+    is_injective(inc) || error("given map is not injective")
+    A = sparse_matrix(inc)
+    all(is_one(only(v)[2]) || is_one(-only(v)[2]) for v in A) || error("given map is not of the required form")
+  end
+  for g in gens(cod)
+    j = findfirst(==(g), img_gens_inc)
+    if isnothing(j)
+      k = findfirst(==(-g), img_gens_inc)
+      if isnothing(k)
+        push!(img_gens, zero(dom))
+      else
+        push!(img_gens, -dom[k::Int])
+      end
+    else
+      push!(img_gens, dom[j::Int])
+    end
+  end
+  res = hom(cod, dom, img_gens)
+  if fac.check && compose(inc, res) != identity_map(dom)
+    error("given map failed to be of the required format.")
+  end
+  return res
+end
+
+function can_compute(fac::SummandProjectionFactory, self::AbsHyperComplexMorphism, i::Tuple)
+  return can_compute_index(fac.inc, i)
+end
+
+
+underlying_morphism(phi::SummandProjection) = phi.internal_morphism

experimental/DoubleAndHyperComplexes/src/Morphisms/Types.jl

@@ -57,15 +57,14 @@ domain(phi::HyperComplexMorphism) = phi.domain
 codomain(phi::HyperComplexMorphism) = phi.codomain
 
 function getindex(phi::HyperComplexMorphism{<:Any, <:Any, MorphismType}, i::Tuple) where {MorphismType}
+  can_compute(phi.fac, phi, i) || error("index out of bounds")
   # No caching deflects to production
   !isdefined(phi, :map_cache) && return phi.fac(phi, i)::MorphismType
 
   # The case of cached results
-  haskey(phi.map_cache, i) && return phi.map_cache[i]
-  can_compute(phi.fac, phi, i) || error("index out of bounds")
-  result = phi.fac(phi, i)::MorphismType
-  phi.map_cache[i] = result
-  return result
+  return get!(phi.map_cache, i) do
+    phi.fac(phi, i)
+  end::MorphismType
 end
 
 offset(phi::HyperComplexMorphism) = phi.offset
@@ -162,3 +161,41 @@ mutable struct MapLifter{MorphismType} <: HyperComplexMorphismFactory{MorphismTy
   end
 end
 
+# Induced maps for Koszul complexes
+struct InducedKoszulMorFactory{MorphismType} <: HyperComplexMorphismFactory{MorphismType}
+  dom::HomogKoszulComplex
+  cod::HomogKoszulComplex
+  A::SMat # the transition matrix between the generators
+
+  function InducedKoszulMorFactory(
+      dom::HomogKoszulComplex,
+      cod::HomogKoszulComplex,
+      A::SMat
+    )
+    return new{ModuleFPHom}(dom, cod, A)
+  end
+end
+
+@attributes mutable struct InducedKoszulMorphism{DomainType, CodomainType, MorphismType} <: AbsHyperComplexMorphism{DomainType, CodomainType, MorphismType, InducedKoszulMorphism{DomainType, CodomainType, MorphismType}}
+  internal_morphism::HyperComplexMorphism{DomainType, CodomainType, MorphismType}
+
+  function InducedKoszulMorphism(
+      dom::HomogKoszulComplex,
+      cod::HomogKoszulComplex;
+      transition_matrix::SMat=begin
+        S = ring(dom)
+        a = sequence(cod)
+        b = sequence(dom)
+        a_ideal = ideal(S, a)
+        c = sparse_matrix(S, 0, length(a))
+        for f in b
+          push!(c, coordinates(SRow, f, a_ideal))
+        end
+        c
+      end
+    )
+    map_factory = InducedKoszulMorFactory(dom, cod, transition_matrix)
+    internal_morphism = HyperComplexMorphism(dom, cod, map_factory, cached=true, offset=[0 for i in 1:dim(dom)])
+    return new{typeof(dom), typeof(cod), ModuleFPHom}(internal_morphism)
+  end
+end

experimental/DoubleAndHyperComplexes/src/Morphisms/induced_homs.jl

@@ -0,0 +1,175 @@
+#= 
+# Induced complexes on `HomComplex`es.
+#
+# Say, one has morphisms of hypercomplexes `ϕ : C* → D*` and `ψ : E* → F`.
+# Then we would like to be able to get all induced maps in the following 
+# diagram:
+#
+#                   ϕ^*
+#        Hom(D*, E*) → Hom(C*, E*)
+#         ψ_* ↓            ↓ ψ_*
+#        Hom(D*, F*) → Hom(C*, F*)
+#                   ϕ^*
+#        
+# This is achieved by the co- and the contravariant induced homomorphisms.
+=#
+struct InducedContravariantMorphismFactory{MorphismType} <: HyperComplexMorphismFactory{MorphismType}
+  phi::AbsHyperComplexMorphism
+  dom::HomComplex
+  cod::HomComplex
+  common_cod::AbsHyperComplex
+
+  # Fields needed for production
+  function InducedContravariantMorphismFactory(
+      phi::AbsHyperComplexMorphism,
+      D::AbsHyperComplex,
+      dom::HomComplex,
+      cod::HomComplex
+    )
+    return new{ModuleFPHom}(phi, dom, cod, D)
+  end
+end
+
+function hom(phi::ModuleFPHom, M::ModuleFP; 
+    domain::ModuleFP=hom(Oscar.codomain(phi), M),
+    codomain::ModuleFP=hom(Oscar.domain(phi), M)
+  )
+  return lift_homomorphism_contravariant(domain, codomain, phi)
+end
+
+function (fac::InducedContravariantMorphismFactory)(self::AbsHyperComplexMorphism, i::Tuple)
+  dom = fac.dom
+  cod = fac.cod
+  common_cod = fac.common_cod
+  n = dim(common_cod)
+  m = dim(dom) - n
+  a = i[1:m]
+  b = i[m+1:m+n]
+  na = Tuple([-i for i in a])
+  return hom(fac.phi[na], common_cod[b]; domain=dom[i], codomain=cod[i])
+end
+
+function can_compute(fac::InducedContravariantMorphismFactory, self::AbsHyperComplexMorphism, i::Tuple)
+  # Decide whether the outgoing map from index i can be computed
+  dom = fac.dom
+  cod = fac.cod
+  common_cod = fac.common_cod
+  n = dim(common_cod)
+  m = dim(dom) - n
+  a = i[1:m]
+  b = i[m+1:m+n]
+  na = Tuple([-i for i in a])
+  return can_compute_index(fac.phi, na) && can_compute_index(common_cod, b)
+end
+
+
+@attributes mutable struct InducedContravariantMorphism{DomainType, CodomainType, MorphismType} <: AbsHyperComplexMorphism{DomainType, CodomainType, MorphismType, InducedContravariantMorphism{DomainType, CodomainType, MorphismType}}
+  internal_morphism::HyperComplexMorphism{DomainType, CodomainType, MorphismType}
+
+  function InducedContravariantMorphism(
+      phi::AbsHyperComplexMorphism,
+      D::AbsHyperComplex;
+      domain::HomComplex = hom(Oscar.codomain(phi), D),
+      codomain::HomComplex = hom(Oscar.domain(phi), D)
+  )
+    @assert Oscar.codomain(domain) === Oscar.codomain(codomain) === D
+    @assert Oscar.domain(domain) === Oscar.codomain(phi)
+    @assert Oscar.domain(codomain) === Oscar.domain(phi)
+    map_factory = InducedContravariantMorphismFactory(phi, D, domain, codomain)
+    internal_morphism = HyperComplexMorphism(domain, codomain, map_factory, cached=true, offset=[0 for i in 1:dim(domain)])
+    return new{typeof(domain), typeof(codomain), ModuleFPHom}(internal_morphism)
+  end
+end
+
+underlying_morphism(phi::InducedContravariantMorphism) = phi.internal_morphism
+
+function hom(
+    phi::AbsHyperComplexMorphism, 
+    D::AbsHyperComplex;
+    domain::HomComplex = hom(Oscar.codomain(phi), D),
+    codomain::HomComplex = hom(Oscar.domain(phi), D)
+  )
+  return InducedContravariantMorphism(phi, D; domain, codomain)
+end
+
+# The same for covariant induced maps
+struct InducedCovariantMorphismFactory{MorphismType} <: HyperComplexMorphismFactory{MorphismType}
+  phi::AbsHyperComplexMorphism
+  dom::HomComplex
+  cod::HomComplex
+  common_dom::AbsHyperComplex
+
+  # Fields needed for production
+  function InducedCovariantMorphismFactory(
+      phi::AbsHyperComplexMorphism,
+      D::AbsHyperComplex,
+      dom::HomComplex,
+      cod::HomComplex
+    )
+    return new{ModuleFPHom}(phi, dom, cod, D)
+  end
+end
+
+function hom(M::ModuleFP, phi::ModuleFPHom; 
+    domain::ModuleFP=hom(M, Oscar.domain(phi)),
+    codomain::ModuleFP=hom(M, Oscar.codomain(phi))
+  )
+  return lift_homomorphism_covariant(domain, codomain, phi)
+end
+
+function (fac::InducedCovariantMorphismFactory)(self::AbsHyperComplexMorphism, i::Tuple)
+  dom = fac.dom
+  cod = fac.cod
+  common_dom = fac.common_dom
+  n = dim(common_dom)
+  m = dim(dom) - n
+  a = i[1:n]
+  b = i[n+1:m+n]
+  na = Tuple([-i for i in a])
+  return hom(common_dom[na], fac.phi[b]; domain=dom[i], codomain=cod[i])
+end
+
+function can_compute(fac::InducedCovariantMorphismFactory, self::AbsHyperComplexMorphism, i::Tuple)
+  # Decide whether the outgoing map from index i can be computed
+  dom = fac.dom
+  cod = fac.cod
+  common_dom = fac.common_dom
+  n = dim(common_dom)
+  m = dim(dom) - n
+  a = i[1:n]
+  b = i[n+1:m+n]
+  na = Tuple([-i for i in a])
+  return can_compute_index(fac.phi, b) && can_compute_index(common_dom, na)
+end
+
+
+@attributes mutable struct InducedCovariantMorphism{DomainType, CodomainType, MorphismType} <: AbsHyperComplexMorphism{DomainType, CodomainType, MorphismType, InducedCovariantMorphism{DomainType, CodomainType, MorphismType}}
+  internal_morphism::HyperComplexMorphism{DomainType, CodomainType, MorphismType}
+
+  function InducedCovariantMorphism(
+      D::AbsHyperComplex,
+      phi::AbsHyperComplexMorphism;
+      domain::HomComplex = hom(D, Oscar.codomain(phi)),
+      codomain::HomComplex = hom(D, Oscar.domain(phi))
+  )
+    @assert Oscar.domain(domain) === Oscar.domain(codomain) === D
+    @assert Oscar.codomain(domain) === Oscar.domain(phi)
+    @assert Oscar.codomain(codomain) === Oscar.codomain(phi)
+    map_factory = InducedCovariantMorphismFactory(phi, D, domain, codomain)
+
+    internal_morphism = HyperComplexMorphism(domain, codomain, map_factory, cached=true, offset=[0 for i in 1:dim(domain)])
+    return new{typeof(domain), typeof(codomain), ModuleFPHom}(internal_morphism)
+  end
+end
+
+underlying_morphism(phi::InducedCovariantMorphism) = phi.internal_morphism
+
+function hom(
+    D::AbsHyperComplex,
+    phi::AbsHyperComplexMorphism;
+    domain::HomComplex = hom(D, Oscar.domain(phi)),
+    codomain::HomComplex = hom(D, Oscar.codomain(phi))
+  )
+  return InducedCovariantMorphism(D, phi; domain, codomain)
+end
+

experimental/DoubleAndHyperComplexes/src/Morphisms/new_koszul_complexes.jl

@@ -0,0 +1,55 @@
+# Induced map of (homogeneous) Koszul complexes
+#
+# Let `S` be a graded ring and `a = (a₁,…,aₘ)` and `b = (b₁,…,bₙ)` two sequences 
+# in `S` with `bⱼ = ∑ᵢcⱼᵢ ⋅ aᵢ` for some matrix `C = (cⱼᵢ) ∈ Sⁿˣᵐ`. 
+# Then there is a natural map of Koszul complexes
+#
+#         b      b       b
+#   ⋀⁰ Sⁿ ← ⋀¹Sⁿ ← ⋀² Sⁿ ← …
+#     ↓id    ↓c     ↓c
+#   ⋀⁰ Sᵐ ← ⋀¹Sᵐ ← ⋀² Sᵐ ← …
+#         a      a       a
+#
+# This is to construct that morphism.
+function (fac::InducedKoszulMorFactory)(self::AbsHyperComplexMorphism, I::Tuple)
+  p = first(I)
+  dom = fac.dom[p]
+  cod = fac.cod[p]
+  A = matrix(fac.A)
+  n = ngens(fac.dom)
+  m = ngens(fac.cod)
+  img_gens = elem_type(cod)[]
+  for (i, ind_dom) in enumerate(combinations(n, p))
+    ii = data(ind_dom)::Vector{Int}
+    img = zero(cod)
+    for (j, ind_cod) in enumerate(combinations(m, p))
+      jj = data(ind_cod)::Vector{Int}
+      A_sub = A[ii, jj]
+      c = det(A_sub)
+      is_zero(c) && continue
+      img += c*cod[j]
+    end
+    push!(img_gens, img)
+  end
+  return hom(dom, cod, img_gens)
+end
+
+function can_compute(fac::InducedKoszulMorFactory, self::AbsHyperComplexMorphism, i::Tuple)
+  return can_compute_index(fac.dom, i) && can_compute_index(fac.cod, i)
+end
+
+
+# The return type for `coordinates` for ideals is not yet unified.
+# This implementation is used to provide output as `SRow`
+coordinates(::Type{OutputType}, f::T, I::Ideal{T}) where {OutputType<:SRow, T<:RingElem} = coordinates(f, I)
+
+function coordinates(::Type{OutputType}, f::T, I::Ideal{T}) where {OutputType<:SRow, T<:MPolyRingElem}
+  R = parent(f)
+  c = coordinates(f, I)::MatrixElem
+  sparse_row(R, [(i, c[1, i]) for i in 1:ngens(I) if !is_zero(c[1, i])])
+end
+
+
+
+underlying_morphism(phi::InducedKoszulMorphism) = phi.internal_morphism
+