Adv/algebraic shifting

Project.toml

@@ -16,6 +16,7 @@ Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
 Nemo = "2edaba10-b0f1-5616-af89-8c11ac63239a"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 Polymake = "d720cf60-89b5-51f5-aff5-213f193123e7"
+ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 RandomExtensions = "fb686558-2515-59ef-acaa-46db3789a887"
 Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
@@ -37,6 +38,7 @@ Markdown = "1.6"
 Nemo = "0.47.1"
 Pkg = "1.6"
 Polymake = "0.11.20"
+ProgressMeter = "1.10.2"
 Random = "1.6"
 RandomExtensions = "0.4.3"
 Serialization = "1.6"

docs/oscar_references.bib

@@ -669,6 +669,14 @@ @Book{Cut04
   doi           = {10.1090/gsm/063}
 }
 
+@Article{D-VJL24,
+  author        = {Della Vecchia, Antony and Joswig, Michael and Lenzen, Fabian},
+  title         = {Partial Algebraic Shifting},
+  year          = {2024},
+  eprint        = {2410.24044},
+  archiveprefix = {arXiv}
+}
+
 @InCollection{DE02,
   author        = {Decker, Wolfram and Eisenbud, David},
   title         = {Sheaf algorithms using the exterior algebra},
@@ -1722,6 +1730,24 @@ @Article{Kah10
   doi           = {10.1007/s10463-010-0290-9}
 }
 
+@InProceedings{Kal02,
+  author        = {Kalai, Gil},
+  title         = {Algebraic shifting},
+  editor        = {Hibi, Takayuki},
+  booktitle     = {Computational commutative algebra and combinatorics},
+  series        = {Advanced Studies in Pure Mathematics},
+  number        = {33},
+  publisher     = {Mathematical Society of Japan},
+  pages         = {121--163},
+  year          = {2002},
+  doi           = {10.2969/aspm/03310121},
+  venue         = {Osaka},
+  eventdate     = {1999},
+  shortseries   = {Adv. Stud. Pure Math.},
+  shortpublisher= {Math. Soc. Japan},
+  location      = {Tokyo}
+}
+
 @Article{Kem02,
   author        = {Kemper, Gregor},
   title         = {The calculation of radical ideals in positive characteristic},

experimental/AlgebraicShifting/README.md

@@ -0,0 +1,10 @@
+# Algebraic Shifting
+
+## Aims
+
+This package grew out of an ongoing project of Antony Della Vecchia, Michael Joswig and Fabian Lenzen on [Partial Algebraic Shifting](https://arxiv.org/abs/2410.24044).
+Part of this project is the development of new methods for algebraic shifting; these are implemented here.
+
+## Status
+
+Full and partial shifting in the exterior algebra fully functional.

experimental/AlgebraicShifting/docs/doc.main

@@ -0,0 +1,8 @@
+[
+    "Algebraic Shifting" => [
+        "introduction.md",
+        "exterior_shifting.md",
+        "partial_shift_graph.md"
+    ]
+]
+

experimental/AlgebraicShifting/docs/src/exterior_shifting.md

@@ -0,0 +1,24 @@
+```@meta
+CurrentModule = Oscar
+DocTestSetup = Oscar.doctestsetup()
+```
+
+# Exterior Shifting
+
+## Uniform Hypergraphs
+```@docs
+uniform_hypergraph
+```
+
+## Matrix Constructions
+
+```@docs
+generic_unipotent_matrix
+rothe_matrix
+compound_matrix
+```
+
+## Exterior (Partial) Shifting
+```@docs
+exterior_shift
+```

experimental/AlgebraicShifting/docs/src/introduction.md

@@ -0,0 +1,29 @@
+```@meta
+CurrentModule = Oscar
+DocTestSetup = Oscar.doctestsetup()
+```
+
+
+# Introduction
+
+Algebraic shifting is a widely applicable method for converting a uniform hypergraph $S$ into another hypergraph, $\Delta(S)$, which is somehow simpler but still retains key properties of $S$.
+Often this is applied to simplicial complexes, where each layer of $(k-1)$-faces forms a $k$-uniform hypergraph.
+
+Here we focus on full and partial algebraic shifting in the exterior algebra.
+For general background on the subject we refer to [Kal02](@cite); for details concerning the implementation see [D-VJL24](@cite).
+
+
+## Status
+
+This part of OSCAR is in an experimental state; please see [Adding new projects to experimental](@ref) for what this means.
+
+## Contact
+
+Please direct questions about this part of OSCAR to the following people:
+* [Antony Della Vecchia](https://antonydellavecchia.github.io)
+* [Michael Joswig](https://page.math.tu-berlin.de/~joswig/)
+
+
+You can ask questions in the [OSCAR Slack](https://www.oscar-system.org/community/#slack).
+
+Alternatively, you can [raise an issue on github](https://www.oscar-system.org/community/#how-to-report-issues).

experimental/AlgebraicShifting/docs/src/partial_shift_graph.md

@@ -0,0 +1,12 @@
+```@meta
+CurrentModule = Oscar
+DocTestSetup = Oscar.doctestsetup()
+```
+
+# Partial Shift Graph
+
+```@docs
+partial_shift_graph_vertices
+partial_shift_graph
+contracted_partial_shift_graph
+```

experimental/AlgebraicShifting/src/AlgebraicShifting.jl

@@ -0,0 +1,119 @@
+include("UniformHypergraph.jl")
+include("PartialShift.jl")
+include("PartialShiftGraph.jl")
+
+export UniformHypergraph
+
+export compound_matrix
+export contracted_partial_shift_graph
+export exterior_shift
+export face_size
+export generic_unipotent_matrix
+export partial_shift_graph
+export partial_shift_graph_vertices
+export rothe_matrix
+export uniform_hypergraph
+
+function independent_columns(A::MatElem)
+  col_indices = Int[]
+  row_index = 1
+  row_bound = nrows(A)
+  for col_index in 1:ncols(A)
+    if !is_zero(A[row_index, col_index])
+      push!(col_indices, col_index)
+      row_index += 1
+    end
+    row_index > row_bound && break
+  end
+  return col_indices
+end
+
+
+"""
+    symmetric_shift(F::Field, K::SimplicialComplex)
+
+Returns the symmetric shift of `K`
+
+see survey on algebraic shifting Gil Kalai (properly cite at some point)
+"""
+function symmetric_shift(F::Field, K::SimplicialComplex;
+                         change_of_basis::T = nothing) where T <: Union{Nothing, MatElem}
+
+  n = n_vertices(K)
+  is_generic = false
+  if isnothing(change_of_basis)
+    is_generic = true
+    # generic change of basis
+    Fy, y = polynomial_ring(F, :y => (1:n, 1:n))
+    change_of_basis = matrix(Fy, hcat(y))
+    matrix_base = Fy
+  else
+    matrix_base = base_ring(change_of_basis)
+    if matrix_base isa MPolyRing
+      is_generic = true
+    end
+  end
+
+  Rx, x = polynomial_ring(matrix_base, n)  
+  # the generators of the stanley reisner ideal are combinations of [x_1, ..., x_n]
+  R_K, _ = stanley_reisner_ring(Rx, K)
+
+  # the computation is a over the field of fractions Fyx
+  # we use a different ring to generate monomial_basis, coefficients need to be a field,
+  # but we want to avoid using fraction field of Ry during row reduction 
+  mb_ring, z = graded_polynomial_ring(F, n)
+
+
+  input_faces = apply_on_faces(K) do (dim_face, faces)
+    r = dim_face + 1
+
+    mb = reverse(monomial_basis(mb_ring, r))
+    A = Vector{elem_type(matrix_base)}[]
+    mb_exponents = first.(collect.(exponents.(mb))) # gets monomial exponents
+
+    for b in mb
+      # need to compare with some alternatives
+      transformed_monomial = evaluate(b, change_of_basis * gens(R_K))
+
+      # we need to iterate through exponents here since the functions terms, coefficients or exponents
+      # do not return 0 terms and we need to make sure the generic col aligns with the others
+      # this is needed for the case when the field has finite characteristic
+      # we use the lift because currently there is no function for get the coeff of
+      # a MPolyQuoRingElem, which means we also need to check if it's zero before adding the coefficient
+      col = [
+        !is_zero(R_K(monomial(Rx, e))) ? coeff(lift(transformed_monomial), e) : matrix_base(0)
+        for e in mb_exponents]
+
+      push!(A, col)
+    end
+
+    C = matrix(matrix_base, reduce(hcat, A))
+
+    if is_generic
+      Oscar.ModStdQt.ref_ff_rc!(C)
+    else
+      rref!(C)
+    end
+
+    smallest_basis_el = z[r]^r
+    smallest_index = findfirst(a -> a == smallest_basis_el, mb)
+    col_indices = filter(x -> x >= smallest_index, independent_columns(C))
+    monomial_exponents = first.(exponents.(mb[col_indices]))
+
+    shifted_sets = Vector{Int}[]
+    for me in monomial_exponents
+      shifted_set = Int[]
+      index_count = 1
+      for (i, e) in enumerate(me)
+        for j in 1:e
+          push!(shifted_set, i - (r - index_count))
+          index_count += 1
+        end
+      end
+      push!(shifted_sets, shifted_set)
+    end
+    return shifted_sets
+  end
+
+  return simplicial_complex(input_faces)
+end