From d4e9082c07b92e55b256d74317b8529c7438a247 Mon Sep 17 00:00:00 2001 From: Wolfram Decker Date: Wed, 28 Feb 2024 17:32:52 +0100 Subject: [PATCH] Docu invariants lin. red. groups (Lakshmi Ramesh and Wolfram Decker) (#3443) Co-authored-by: Johannes Schmitt (cherry picked from commit 73ba78702948eb97806db7efab1545dbb41a15cf) --- docs/src/InvariantTheory/intro.md | 6 +- docs/src/InvariantTheory/reductive_groups.md | 66 ++++-- .../InvariantTheory/src/InvariantTheory.jl | 192 +++++++++++++++++- .../src/TorusInvariantsFast.jl | 10 +- experimental/InvariantTheory/test/runtests.jl | 2 +- 5 files changed, 246 insertions(+), 30 deletions(-) diff --git a/docs/src/InvariantTheory/intro.md b/docs/src/InvariantTheory/intro.md index 8f84884d9e99..87610955214e 100644 --- a/docs/src/InvariantTheory/intro.md +++ b/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].$ diff --git a/docs/src/InvariantTheory/reductive_groups.md b/docs/src/InvariantTheory/reductive_groups.md index c7c7c367beb6..d3009a892055 100644 --- a/docs/src/InvariantTheory/reductive_groups.md +++ b/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) +``` diff --git a/experimental/InvariantTheory/src/InvariantTheory.jl b/experimental/InvariantTheory/src/InvariantTheory.jl index a5b895f6d20f..930b48407408 100644 --- a/experimental/InvariantTheory/src/InvariantTheory.jl +++ b/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,7 +21,7 @@ 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 @@ -29,14 +29,14 @@ mutable struct LinearlyReductiveGroup 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 diff --git a/experimental/InvariantTheory/src/TorusInvariantsFast.jl b/experimental/InvariantTheory/src/TorusInvariantsFast.jl index 05c90697852f..04b3a9f6f209 100644 --- a/experimental/InvariantTheory/src/TorusInvariantsFast.jl +++ b/experimental/InvariantTheory/src/TorusInvariantsFast.jl @@ -1,4 +1,4 @@ -export torus_group, rank, field, representation_from_weights, weights, group, invariant_ring, poly_ring, representation, fundamental_invariants, affine_algebra +export torus_group, rank, field, representation_from_weights, weights, group, invariant_ring, polynomial_ring, representation, fundamental_invariants, affine_algebra ##################### #Setting up tori for fast torus algorithm @@ -209,7 +209,7 @@ graded multivariate polynomial ring in 4 variables over QQ under group action of invariant_ring(R::RepresentationTorusGroup) = TorGrpInvRing(R) @doc raw""" - poly_ring(RT::TorGrpInvRing) + polynomial_ring(RT::TorGrpInvRing) # Examples ```jldoctest @@ -218,7 +218,7 @@ Torus of rank 2 over QQ ``` """ -poly_ring(R::TorGrpInvRing) = R.poly_ring +polynomial_ring(R::TorGrpInvRing) = R.poly_ring @doc raw""" group(RT::TorGrpInvRing) @@ -269,7 +269,7 @@ function fundamental_invariants(z::TorGrpInvRing) return z.fundamental else R = z.representation - z.fundamental = torus_invariants_fast(weights(R), poly_ring(z)) + z.fundamental = torus_invariants_fast(weights(R), polynomial_ring(z)) return z.fundamental end end @@ -403,7 +403,7 @@ function affine_algebra(R::TorGrpInvRing) V = fundamental_invariants(R) s = length(V) S,t = polynomial_ring(field(group(representation(R))), "t"=>1:s) - R_ = poly_ring(R) + R_ = polynomial_ring(R) StoR = hom(S,R_,V) I = kernel(StoR) Q, StoQ = quo(S,I) diff --git a/experimental/InvariantTheory/test/runtests.jl b/experimental/InvariantTheory/test/runtests.jl index 3de3a24b3bde..9e9412d0b130 100644 --- a/experimental/InvariantTheory/test/runtests.jl +++ b/experimental/InvariantTheory/test/runtests.jl @@ -52,7 +52,7 @@ T = torus_group(QQ,2) r = representation_from_weights(T, [1 0; 0 1; -1 -1; -1 1]) I = invariant_ring(r) - R = poly_ring(I) + R = polynomial_ring(I) X = gens(R) f = fundamental_invariants(I) @test f == [X[1]*X[2]*X[3], X[1]^2*X[3]*X[4]]