Docu invariants lin. red. groups (Lakshmi Ramesh and Wolfram Decker) (#…

…3443)

Co-authored-by: Johannes Schmitt <[email protected]>
(cherry picked from commit 73ba787)

docs/src/InvariantTheory/intro.md

@@ -19,7 +19,11 @@ $K[V]:=S(V^*)=\bigoplus_{d\geq 0} S^d V^*$
 
 which preserves the grading.
 
-The *invariants* of $G$ are the fixed points of this action, its *invariant ring* is the graded subalgebra
+!!! note
+    In OSCAR, group actions are by convention assumed to be right actions and we follow this convention with our definition above.
+    Note, however, that the left action given by $\pi \;\!   . \;\! f :=  f \circ \rho(\pi^{-1})$ is quite common in the literature.
+
+The *invariants* of $G$ are the fixed points of the action defined above, its *invariant ring* is the graded subalgebra
 
 $K[V]^G:=\{f\in K[V] \mid f \;\!   . \;\! \pi =f {\text { for any }} \pi\in G\} \subset K[V].$
 

docs/src/InvariantTheory/reductive_groups.md

@@ -4,18 +4,23 @@ CurrentModule = Oscar
 
 # Invariants of Linearly Reductive Groups
 
-In this section, with notation as in the introduction to this chapter, $G$ will be a *linearly algebraic group* over an algebraically closed field $K$, and ``\rho: G \to \text{GL}(V)\cong \text{GL}_n(K)`` will be a *rational* representation of $G$. As in the previous sections, ``G`` will act on $K[V]\cong K[x_1, \dots, x_n]$ by linear substitution:
-
-$(f \;\!   . \;\! \pi)  (x_1, \dots, x_n)  = f((x_1, \dots, x_n) \cdot \rho(\pi)) \text{ for all } \pi\in G.$
+In this section, with notation as in the introduction to this chapter,
+$G$ will be a *linearly algebraic group* over an algebraically closed
+field $K$, $\rho: G \to \text{GL}(V)\cong \text{GL}_n(K)$ will
+be a *rational* representation of $G$, and
+$G$ will act on $K[V]\cong K[x_1, \dots, x_n]$ by linear
+substitution: If $\rho(\pi) = (a_{i, j})$, then 
 
+$(f \;\!   . \;\! \pi)  (x_1, \dots, x_n) = f\bigl(\sum_j a_{1, j}x_j, \dots, \sum_j a_{n, j}x_j\bigr).$
 
 !!! note
 
     - The definition of linear reductivity guarantees the existence of a Reynolds operator $\mathcal R: K[V] \to K[V]$. 
     - By Hilbert's celebrated finiteness theorem, $K[V]^G$ is finitely generated as a $K$-algebra.
-    - By a result of Hochster and Roberts, $K[V]^G$ is Cohen-Macaulay. 
+    - By a result of Hochster and Roberts, $K[V]^G$ is Cohen-Macaulay.
 
-In cases where the Reynold's operator can be explicitly handled, generators of invariant rings of linearly reductive groups can be found in two steps using Derksen's algorithm, see [Der99](@cite) :
+In cases where the Reynold's operator is explicitly known, generators of invariant rings of linearly reductive groups
+can be found in two steps using Derksen's algorithm, see [Der99](@cite) :
 
 - First, compute generators of Hilbert's null-cone ideal.
 - Then, apply the Reynold's operator to these generators.
@@ -24,32 +29,59 @@ See also [DK15](@cite) and [DJ98](@cite).
 
 ## Creating Invariant Rings
 
-There are no exact means to handle algebraically closed fields on the computer. For the computation of invariant rings in the above setting, on the other hand, there is no need to deal with explicit elements of ``G`` or with its group structure. The implementation of Derksen's algorithm in OSCAR can  handle situations where both $G$ and the representation $\rho$ are defined over an exact subfield $k$ of $K$ which is supported by OSCAR: 
+### How Linearly Reductive Groups and Their Representations are Given
+
+For the computation of invariant rings in the above setting, there is no need to deal with explicit elements of ``G`` or with its group structure.
+The implementation of Derksen's algorithm in OSCAR can  handle situations where both $G$ and the representation $\rho$ are defined over an exact
+subfield $k$ of $K$ which is supported by OSCAR: 
 
 - ``G`` is  specified as an affine algebraic variety by polynomials with coefficients in $k$;
 - ``\rho: G \to \text{GL}(V) \cong \text{GL}_n(K)`` is specified by an $n\times n$ matrix whose entries are polynomials in the same variables as those specifying $G$, with coefficients in $k$.
 
-All computations are then performed over $k$.
+!!! note
+    Proceeding as above is not a problem: Derksen's algorithms relies on Gröbner bases techniques and means to compute
+    Reynolds operators. It does, thus, not change the initial ground field $k$. That is, all computations are performed over $k$
+	and computations over any extension field of $k$ would lead to the same results.
 
-!!! warning
-    OSCAR does neither check whether the affine variety defined by the given equations carries a group structure which makes it a linearly reductive group nor does it check whether the given $n\times n$ matrix really defines a representation.
-
+In OSCAR, the basic set-up for a linearly reductive group in the context of Derksen's algorithm is provided by the 
+function `linearly_reductive_group`. At current state, this only supports rational actions of  the special linear group
+(in characteristic zero). For the action of this group by linear substitution on forms, an explicit Reynolds operator is
+given by Cayley's Omega-process. We show this at work later in this section.
+
+
+```@docs
+linearly_reductive_group(sym::Symbol, m::Int, K::Field)
+```
 
+```@docs
+linearly_reductive_group(sym::Symbol, m::Int, R::MPolyRing)
+```
 
-## Basic Data Associated to Invariant Rings
+```@docs
+representation_on_forms(G::LinearlyReductiveGroup, d::Int)
+```
 
-## The Reynolds Operator
+### Constructors for Invariant Rings
 
-Omega-process
+```@docs
+invariant_ring(r::RepresentationLinearlyReductiveGroup)
+```
 
-## Generators of Hilbert's Null-Cone Ideal
+```@docs
+invariant_ring(R::MPolyDecRing, r::RepresentationLinearlyReductiveGroup)
+```
+
+ ### The Reynolds Operator
 
-## Generators of the Invariant Ring
+```@docs
+reynolds_operator(R::RedGrpInvRing, f::MPolyRingElem)
+```
 
 ## Fundamental Systems of Invariants
 
-## Invariant Rings as Affine Algebras
-
+```@docs
+fundamental_invariants(RG::RedGrpInvRing)
+```
 
 
 

experimental/InvariantTheory/src/InvariantTheory.jl

@@ -5,7 +5,7 @@
 
 export LinearlyReductiveGroup, linearly_reductive_group, representation_matrix, group, reynolds_operator, group_ideal, canonical_representation, natural_representation
 export RepresentationLinearlyReductiveGroup, representation_reductive_group, representation_on_forms, representation_matrix, direct_sum, tensor
-export RedGrpInvRing, invariant_ring, fundamental_invariants, NullConeIdeal, poly_ring, representation
+export RedGrpInvRing, invariant_ring, fundamental_invariants, NullConeIdeal, polynomial_ring, representation, affine_algebra
 ##########################
 #Setting up Reductive Groups 
 ##########################
@@ -21,22 +21,22 @@ mutable struct LinearlyReductiveGroup
 
     function LinearlyReductiveGroup(sym::Symbol, m::Int, fld::Field) #have not decided the representation yet
         #check char(fld)
-        @assert sym == :SL 
+        @assert sym == :SL && characteristic(fld) == 0
         R, _ = polynomial_ring(fld, :z => (1:m,1:m))
         return LinearlyReductiveGroup(sym, m, R)
     end
 
     function LinearlyReductiveGroup(sym::Symbol, m::Int, pring::MPolyRing) #the ring input is the group ring
         #check char(field)
         G = new()
-        @assert sym == :SL 
         fld = base_ring(pring)
+        @assert sym == :SL  && characteristic(fld) == 0 
         characteristic(fld) == 0 || error("Characteristic should be 0 for linearly reductive groups")
         G.field = fld
         @req m^2  == ngens(pring) "ring not compatible"
         G.group = (sym,m)
         G.reynolds_operator = reynolds_slm
-        M = matrix(pring, m, m, gens(pring))
+        M = transpose(matrix(pring, m, m, gens(pring)))
         G.canonical_representation = M
         G.group_ideal = ideal([det(M) - 1])
         #base ring of M has to be the same as the representation matrix when that is created later.
@@ -54,8 +54,51 @@ function Base.show(io::IO, G::LinearlyReductiveGroup)
 end
 
 #getter functions
-linearly_reductive_group(sym::Symbol, m::Int, R::MPolyRing) = LinearlyReductiveGroup(sym,m,R)
+
+@doc raw"""
+    linearly_reductive_group(sym::Symbol, m::Int, K::Field)
+
+Return the linearly reductive group indicated by `sym`.
+
+Currently, the supported options for `sym` are:
+* `:SL`, corresponding to the special linear group (of degree $m$ over the field $K$).
+
+# Examples
+```jldoctest
+julia> G = linearly_reductive_group(:SL, 2, QQ)
+Reductive group SL2
+  over QQ
+
+julia> group_ideal(G)
+Ideal generated by
+  z[1, 1]*z[2, 2] - z[2, 1]*z[1, 2] - 1
+```
+"""
 linearly_reductive_group(sym::Symbol, m::Int, F::Field) =  LinearlyReductiveGroup(sym,m,F)
+
+@doc raw"""
+    linearly_reductive_group(sym::Symbol, m::Int, R::MPolyRing)
+
+Return the linearly reductive group indicated by `sym`.
+
+Currently, the supported options for `sym` are:
+* `:SL`, corresponding to the special linear group (of degree $m$ over the base field $K$ of $R$, where $R$ is the polynomial ring in which the defining ideal of SL$(m, K)$ lives).
+
+# Examples
+```jldoctest
+julia> S, z = polynomial_ring(QQ, "c"=> (1:2, 1:2));
+
+julia> G = linearly_reductive_group(:SL,2,S)
+Reductive group SL2
+  over QQ
+
+julia> group_ideal(G)
+Ideal generated by
+  c[1, 1]*c[2, 2] - c[2, 1]*c[1, 2] - 1
+```
+"""
+linearly_reductive_group(sym::Symbol, m::Int, R::MPolyRing) = LinearlyReductiveGroup(sym,m,R)
+
 group(G::LinearlyReductiveGroup) = G.group
 field(G::LinearlyReductiveGroup) = G.field
 reynolds_operator(G::LinearlyReductiveGroup) = G.reynolds_operator
@@ -105,6 +148,25 @@ group(R::RepresentationLinearlyReductiveGroup) = R.group
 representation_matrix(R::RepresentationLinearlyReductiveGroup) = R.rep_mat
 vector_space_dimension(R::RepresentationLinearlyReductiveGroup) = ncols(R.rep_mat)
 
+@doc raw"""
+    representation_on_forms(G::LinearlyReductiveGroup, d::Int)
+
+If `G` is the special linear group acting by linear substitution on forms of degree `d`, return the corresponding representation.
+
+# Examples
+```jldoctest
+julia> G = linearly_reductive_group(:SL, 2, QQ);
+
+julia> r = representation_on_forms(G, 2)
+Representation of SL2
+  on symmetric forms of degree 2
+
+julia> representation_matrix(r)
+[      z[1, 1]^2                   2*z[1, 1]*z[2, 1]         z[2, 1]^2]
+[z[1, 1]*z[1, 2]   z[1, 1]*z[2, 2] + z[2, 1]*z[1, 2]   z[2, 1]*z[2, 2]]
+[      z[1, 2]^2                   2*z[1, 2]*z[2, 2]         z[2, 2]^2]
+```
+"""
 function representation_on_forms(G::LinearlyReductiveGroup, d::Int)
     @assert G.group[1] == :SL
     return RepresentationLinearlyReductiveGroup(G, d)
@@ -271,7 +333,44 @@ end
     end
 end
 
+@doc raw"""
+    invariant_ring(r::RepresentationLinearlyReductiveGroup)
+
+Return the invariant ring under the action defined by the representation `r` on an implicitly generated polynomial ring of appropriate dimension.
+
+# Examples
+```jldoctest
+julia> G = linearly_reductive_group(:SL, 2, QQ);
+
+julia> r = representation_on_forms(G, 2);
+
+julia> RG = invariant_ring(r)
+Invariant Ring of
+graded multivariate polynomial ring in 3 variables over QQ
+  under group action of SL2
+```
+"""
 invariant_ring(R::RepresentationLinearlyReductiveGroup) = RedGrpInvRing(R)
+
+@doc raw"""
+    invariant_ring(R::MPolyDecRing, r::RepresentationLinearlyReductiveGroup)
+
+Return the invariant subring of `R` under the action induced by the representation of `r` on `R`.
+
+# Examples
+```jldoctest
+julia> G = linearly_reductive_group(:SL, 3, QQ);
+
+julia> r = representation_on_forms(G, 3);
+
+julia> S, x = graded_polynomial_ring(QQ, "x" => 1:10);
+
+julia> RG = invariant_ring(S, r)
+Invariant Ring of
+graded multivariate polynomial ring in 10 variables over QQ
+  under group action of SL3
+```
+"""
 invariant_ring(ring::MPolyDecRing, R::RepresentationLinearlyReductiveGroup) = RedGrpInvRing(R, ring)
 
 @attr MPolyIdeal function NullConeIdeal(R::RedGrpInvRing) 
@@ -280,10 +379,31 @@ invariant_ring(ring::MPolyDecRing, R::RepresentationLinearlyReductiveGroup) = Re
     return ideal(generators(Z.group, I, Z.rep_mat))
 end
 
-poly_ring(R::RedGrpInvRing) = R.poly_ring
+polynomial_ring(R::RedGrpInvRing) = R.poly_ring
 group(R::RedGrpInvRing) = R.group
 representation(R::RedGrpInvRing) = R.representation
 
+
+
+@doc raw"""
+    fundamental_invariants(RG::RedGrpInvRing)
+
+Return a system of fundamental invariants for `RG`.
+
+# Examples
+```jldoctest
+julia> G = linearly_reductive_group(:SL, 2, QQ);
+
+julia> r = representation_on_forms(G, 2);
+
+julia> RG = invariant_ring(r);
+
+julia> fundamental_invariants(RG)
+1-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
+ -X[1]*X[3] + X[2]^2
+
+```
+"""
 @attr function fundamental_invariants(z::RedGrpInvRing) #unable to use abstract type
     R = z.representation
     I, M = proj_of_image_ideal(R.group, R.rep_mat)
@@ -489,9 +609,69 @@ function reynolds_operator(X::RepresentationLinearlyReductiveGroup, elem::MPolyR
     return reverse_map(f)
 end
 
+@doc raw"""
+    reynolds_operator(RG::RedGrpInvRing, f::MPolyRingElem)
+
+Return the image of `f` under the Reynolds operator corresponding to `RG`.
+
+# Examples
+```jldoctest
+julia> G = linearly_reductive_group(:SL, 3, QQ);
+
+julia> r = representation_on_forms(G, 3);
+
+julia> S, x = graded_polynomial_ring(QQ, "x" => 1:10);
+
+julia> RG = invariant_ring(S, r);
+
+julia> 75*reynolds_operator(RG, x[5]^4)
+x[1]*x[4]*x[8]*x[10] - x[1]*x[4]*x[9]^2 - x[1]*x[5]*x[7]*x[10] + x[1]*x[5]*x[8]*x[9] + x[1]*x[6]*x[7]*x[9] - x[1]*x[6]*x[8]^2 - x[2]^2*x[8]*x[10] + x[2]^2*x[9]^2 + x[2]*x[3]*x[7]*x[10] - x[2]*x[3]*x[8]*x[9] + x[2]*x[4]*x[5]*x[10] - x[2]*x[4]*x[6]*x[9] - 2*x[2]*x[5]^2*x[9] + 3*x[2]*x[5]*x[6]*x[8] - x[2]*x[6]^2*x[7] - x[3]^2*x[7]*x[9] + x[3]^2*x[8]^2 - x[3]*x[4]^2*x[10] + 3*x[3]*x[4]*x[5]*x[9] - x[3]*x[4]*x[6]*x[8] - 2*x[3]*x[5]^2*x[8] + x[3]*x[5]*x[6]*x[7] + x[4]^2*x[6]^2 - 2*x[4]*x[5]^2*x[6] + x[5]^4
+```
+"""
 function reynolds_operator(R::RedGrpInvRing, elem::MPolyRingElem)
     X = R.representation
     return reynolds_operator(X, elem)
 end
 
 include("TorusInvariantsFast.jl")
+
+
+#####################Invariant rings as affine algebras
+
+@doc raw"""
+    affine_algebra(RG::RedGrpInvRing)
+
+Return the invariant ring `RG` as an affine algebra (this amounts to compute the algebra syzygies among the fundamental invariants of `RG`).
+
+In addition, if `A` is this algebra, and `R` is the polynomial ring of which `RG` is a subalgebra,
+return the inclusion homomorphism  `A` $\hookrightarrow$ `R` whose image is `RG`.
+
+# Examples
+```jldoctest
+julia> G = linearly_reductive_group(:SL, 2, QQ);
+
+julia> r = representation_on_forms(G, 2);
+
+julia> S, x = graded_polynomial_ring(QQ, "x" => 1:3);
+
+julia> RG = invariant_ring(S, r);
+
+julia> A, AtoS = affine_algebra(RG)
+(Quotient of multivariate polynomial ring by ideal (0), Hom: A -> S)
+```
+"""
+@attr function affine_algebra(R::RedGrpInvRing)
+   V = fundamental_invariants(R)
+   s = length(V)
+   weights_ = zeros(Int, s)
+   for i in 1:s
+       weights_[i] = total_degree(V[i])
+   end
+   S,_ = graded_polynomial_ring(field(group(representation(R))), "t"=>1:s; weights = weights_)
+   R_ = polynomial_ring(R)
+   StoR = hom(S,R_,V)
+   I = kernel(StoR)
+   Q, StoQ = quo(S,I)
+   QtoR = hom(Q,R_,V)
+   return Q, QtoR
+end