adds new docu

Author: ederc

decomposition.md

@@ -0,0 +1,34 @@
+```@meta
+CurrentModule = AlgebraicSolving
+DocTestSetup = quote
+  using AlgebraicSolving
+end
+```
+
+```@setup algebraicsolving
+using AlgebraicSolving
+```
+
+```@contents
+Pages = ["decomposition.md"]
+```
+
+# Equidimensional Decomposition
+
+## Introduction
+
+AlgebraicSolving allows to compute equidimensional decompositions of polynomial
+ideals. This is to be understood in a geometric sense, i.e. given a polynomial
+ideal $I$ it computes ideals $I_1,\dots,I_k$ s.t. $V(I)=\bigcup_{i=1}^{k} V(I_j)$
+and such that each $V(I_j)$ is equidimensional.
+
+The implemented algorithm is the one given in [this paper](https://arxiv.org/abs/2409.17785).
+
+## Functionality
+
+```@docs
+    equidimensional_decomposition(
+	    I::Ideal{T};
+	    info_level::Int=0
+	    ) where {T <: MPolyRingElem}
+```

dimension.md

@@ -0,0 +1,31 @@
+```@meta
+CurrentModule = AlgebraicSolving
+DocTestSetup = quote
+  using AlgebraicSolving
+end
+```
+
+```@setup algebraicsolving
+using AlgebraicSolving
+```
+
+```@contents
+Pages = ["dimension.md"]
+```
+
+# Krull dimension of an ideal
+
+## Introduction
+
+AlgebraicSolving allows to compute the Krull dimension for the ideal spanned
+by given input generators over finite fields of characteristic smaller
+$2^{31}$ and over the rationals.
+
+The underlying engine is provided by msolve.
+
+## Functionality
+
+```@docs
+    dimension(I::Ideal{T}) where T <: MPolyRingElem
+```
+

groebner-bases.md

@@ -0,0 +1,69 @@
+```@meta
+CurrentModule = AlgebraicSolving
+DocTestSetup = quote
+  using AlgebraicSolving
+end
+```
+
+```@setup algebraicsolving
+using AlgebraicSolving
+```
+
+```@contents
+Pages = ["groebner-bases.md"]
+```
+
+# Gröbner bases
+
+## Introduction
+
+AlgebraicSolving allows to compute Gröbner bases for input generators over prime
+fields of characteristic smaller $2^{31}$ or over the rationals w.r.t. the degree
+reverse lexicographical monomial order.
+
+At the moment different variants of Faugère's F4 Algorithm are implemented as
+well as a signature based algorithm to compute Gröbner bases.
+
+## Functionality
+
+```@docs
+    groebner_basis(
+        I::Ideal{T} where T <: MPolyRingElem;
+        initial_hts::Int=17,
+        nr_thrds::Int=1,
+        max_nr_pairs::Int=0,
+        la_option::Int=2,
+        eliminate::Int=0,
+        intersect::Bool=true,
+        complete_reduction::Bool=true,
+        info_level::Int=0
+        )
+```
+
+The engine supports the elimination of one block of variables considering the
+product monomial ordering of two blocks, both ordered w.r.t. the degree
+reverse lexicographical order. One can either directly add the number of
+variables of the first block via the `eliminate` parameter in the
+`groebner_basis` call. By using `intersect=false` it is possible to only 
+use block ordering without intersecting. We have also implemented an alias 
+for this call:
+
+```@docs
+    eliminate(
+        I::Ideal{T} where T <: MPolyRingElem,
+        eliminate::Int;
+        intersect::Bool=true,
+        initial_hts::Int=17,
+        nr_thrds::Int=1,
+        max_nr_pairs::Int=0,
+        la_option::Int=2,
+        complete_reduction::Bool=true,
+        info_level::Int=0
+        )
+```
+
+To compute signature Gröbner bases use
+
+```@docs
+    sig_groebner_basis(sys::Vector{T}; info_level::Int = 0, degbound::Int = 0, mod_ord::Symbol=:POT) where {T <: MPolyRingElem}
+```

hilbert.md

@@ -0,0 +1,40 @@
+```@meta
+CurrentModule = AlgebraicSolving
+DocTestSetup = quote
+  using AlgebraicSolving
+end
+```
+
+```@setup algebraicsolving
+using AlgebraicSolving
+```
+
+```@contents
+Pages = ["hilbert.md"]
+```
+
+# Hilbert series of an ideal
+
+## Introduction
+
+AlgebraicSolving allows to compute the Hilbert series for the ideal spanned
+by given input generators over finite fields of characteristic smaller
+$2^{31}$ and over the rationals.
+
+The underlying engine is provided by msolve.
+
+## Functionality
+
+```@docs
+    hilbert_series(I::Ideal{T}) where T <: MPolyRingElem
+```
+
+In addition, from the same input, AlgebraicSolving can also compute the dimension and degree of the ideal, as well as the Hilbert polynomial and index of regularity.
+
+```@docs
+    hilbert_dimension(I::Ideal{T}) where T <: MPolyRingElem
+
+    hilbert_degree(I::Ideal{T}) where T <: MPolyRingElem
+
+    hilbert_polynomial(I::Ideal{T}) where T <: MPolyRingElem
+```

index.md

@@ -0,0 +1,23 @@
+# Getting Started
+
+AlgebraicSolving is a computer algebra package for the Julia programming 
+language, maintained by Christian Eder, Mohab Safey El Din, Rafael Mohr, Rémi Prébet.
+
+- <https://github.com/algebraic-solving/AlgebraicSolving.jl> (Source code)
+
+The features of AlgebraicSolving include algorithms for computing
+Gröbner bases over finite fields and for computing real solutions.
+The main workhorse of AlgebraicSolving is the [msolve
+library](https://msolve.lip6.fr/) .
+
+## Installation
+
+To use Nemo we require Julia 1.6 or higher. Please see
+<https://julialang.org/downloads/> for instructions on
+how to obtain julia for your system.
+
+At the Julia prompt simply type
+
+```
+julia> using Pkg; Pkg.add("AlgebraicSolving")
+```

katsura.md

@@ -0,0 +1,34 @@
+```@meta
+CurrentModule = AlgebraicSolving
+DocTestSetup = quote
+  using AlgebraicSolving
+end
+```
+
+```@setup algebraicsolving
+using AlgebraicSolving
+```
+
+```@contents
+Pages = ["katsura.md"]
+```
+
+# Examples
+
+Here we include some well-known example multivariate polynomial systems.
+
+## Katsura-n
+
+These systems appeared in a problem of magnetism in physics.
+For a given $n$ `katsura(n)` has $2^n$ solutions and is defined in a
+polynomial ring with $n+1$ variables. For a given polynomial ring `R`
+with $n$ variables `katsura(R)` defines the corresponding system with
+$2^{n-1}$ solutions.
+
+### Functionality
+
+```@docs
+    katsura(n::Int)
+    katsura(R::MPolyRing)
+```
+

normal-forms.md

@@ -0,0 +1,44 @@
+```@meta
+CurrentModule = AlgebraicSolving
+DocTestSetup = quote
+  using AlgebraicSolving
+end
+```
+
+```@setup algebraicsolving
+using AlgebraicSolving
+```
+
+```@contents
+Pages = ["normal-forms.md"]
+```
+
+# Normal forms
+
+## Introduction
+
+AlgebraicSolving allows to compute normal forms of a polynomial resp. a finite
+array of polynomials w.r.t. some given ideal over a finite field of
+characteristic smaller $2^{31}$ w.r.t. the degree reverse lexicographical
+monomial order.
+
+**Note:** It therefore might first compute a Gröbner bases for the ideal.
+## Functionality
+
+```@docs
+    normal_form(
+        f::T,
+        I::Ideal{T};
+        nr_thrds::Int=1,
+        info_level::Int=0
+        ) where T <: MPolyRingElem
+```
+
+```@docs
+    normal_form(
+        F::Vector{T},
+        I::Ideal{T};
+        nr_thrds::Int=1,
+        info_level::Int=0
+        ) where T <: MPolyRingElem
+```

solvers.md

@@ -0,0 +1,66 @@
+```@meta
+CurrentModule = AlgebraicSolving
+DocTestSetup = quote
+  using AlgebraicSolving
+end
+```
+
+```@setup algebraicsolving
+using AlgebraicSolving
+```
+
+```@contents
+Pages = ["solvers.md"]
+```
+
+# Algebraic Systems Solving
+
+## Introduction
+
+AlgebraicSolving allows to solve systems for input generators over finite
+fields of characteristic smaller $2^{31}$ and over the rationals.
+
+The underlying engine is provided by msolve.
+
+## Functionality
+
+```@docs
+    rational_parametrization(
+        I::Ideal{T} where T <: MPolyRingElem;
+        initial_hts::Int=17,
+        nr_thrds::Int=1,
+        max_nr_pairs::Int=0,
+        la_option::Int=2,
+        info_level::Int=0,
+        precision::Int=32
+        )
+
+    real_solutions(
+        I::Ideal{T} where T <: MPolyRingElem;
+        initial_hts::Int=17,
+        nr_thrds::Int=1,
+        max_nr_pairs::Int=0,
+        la_option::Int=2,
+        info_level::Int=0,
+        precision::Int=32
+        )
+    rational_solutions(
+        I::Ideal{T} where T <: MPolyRingElem;
+        initial_hts::Int=17,
+        nr_thrds::Int=1,
+        max_nr_pairs::Int=0,
+        la_option::Int=2,
+        info_level::Int=0,
+        precision::Int=32
+        )
+
+    rational_curve_parametrization(
+        I::Ideal{P} where P<:QQMPolyRingElem;
+        info_level::Int=0,
+        use_lfs::Bool = false,
+        cfs_lfs::Vector{Vector{ZZRingElem}} = Vector{ZZRingElem}[],
+        nr_thrds::Int=1,
+        check_gen::Bool = true
+    )
+```
+