Rename invariant ring types

`InvRing` -> `FinGroupInvarRing`
`RedGrpInvRing` -> `RedGroupInvarRing`
`TorGrpInvRing` -> `TorGroupInvarRing`

docs/src/InvariantTheory/finite_groups.md

@@ -124,64 +124,64 @@ false
 ## The Reynolds Operator
 
 ```@docs
-reynolds_operator(IR::InvRing{FldT, GrpT, T}, f::T) where {FldT, GrpT, T <: MPolyRingElem}
+reynolds_operator(IR::FinGroupInvarRing{FldT, GrpT, T}, f::T) where {FldT, GrpT, T <: MPolyRingElem}
 
-reynolds_operator(IR::InvRing{FldT, GrpT, T}, f::T, chi::GAPGroupClassFunction) where {FldT, GrpT, T <: MPolyRingElem}
+reynolds_operator(IR::FinGroupInvarRing{FldT, GrpT, T}, f::T, chi::GAPGroupClassFunction) where {FldT, GrpT, T <: MPolyRingElem}
 ```
 
 ## Invariants of a Given Degree
 
 ```@docs
-basis(IR::InvRing, d::Int, algorithm::Symbol = :default)
+basis(IR::FinGroupInvarRing, d::Int, algorithm::Symbol = :default)
 
-basis(IR::InvRing, d::Int, chi::GAPGroupClassFunction)
+basis(IR::FinGroupInvarRing, d::Int, chi::GAPGroupClassFunction)
 ```
 
 ```@docs
-iterate_basis(IR::InvRing, d::Int, algorithm::Symbol = :default)
+iterate_basis(IR::FinGroupInvarRing, d::Int, algorithm::Symbol = :default)
 
-iterate_basis(IR::InvRing, d::Int, chi::GAPGroupClassFunction)
+iterate_basis(IR::FinGroupInvarRing, d::Int, chi::GAPGroupClassFunction)
 ```
 
 ## The Molien Series
 
 ```@docs
- molien_series([S::PolyRing], I::InvRing, [chi::GAPGroupClassFunction])
+ molien_series([S::PolyRing], I::FinGroupInvarRing, [chi::GAPGroupClassFunction])
 ```
 
 ## Primary Invariants
 
 ```@docs
-primary_invariants(IR::InvRing)
+primary_invariants(IR::FinGroupInvarRing)
 ```
 
 ## Secondary Invariants
 
 ```@docs
-secondary_invariants(IR::InvRing)
+secondary_invariants(IR::FinGroupInvarRing)
 ```
 
 ```@docs
-irreducible_secondary_invariants(IR::InvRing)
+irreducible_secondary_invariants(IR::FinGroupInvarRing)
 ```
 
 ```@docs
-module_syzygies(RG::InvRing)
+module_syzygies(RG::FinGroupInvarRing)
 ```
 
 ## Fundamental Systems of Invariants
 
 ```@docs
-fundamental_invariants(IR::InvRing, algorithm::Symbol = :default; beta::Int = 0)
+fundamental_invariants(IR::FinGroupInvarRing, algorithm::Symbol = :default; beta::Int = 0)
 ```
 
 ## Invariant Rings as Affine Algebras
 
 ```@docs
-affine_algebra(IR::InvRing)
+affine_algebra(IR::FinGroupInvarRing)
 ```
 
 ## Semi-invariants / relative invariants
 ```@docs
-semi_invariants(IR::InvRing, chi::GAPGroupClassFunction)
+semi_invariants(IR::FinGroupInvarRing, chi::GAPGroupClassFunction)
 ```

docs/src/InvariantTheory/reductive_groups.md

@@ -74,13 +74,13 @@ invariant_ring(R::MPolyDecRing, r::RepresentationLinearlyReductiveGroup)
  ### The Reynolds Operator
 
 ```@docs
-reynolds_operator(R::RedGrpInvRing, f::MPolyRingElem)
+reynolds_operator(R::RedGroupInvarRing, f::MPolyRingElem)
 ```
 
 ## Fundamental Systems of Invariants
 
 ```@docs
-fundamental_invariants(RG::RedGrpInvRing)
+fundamental_invariants(RG::RedGroupInvarRing)
 ```
 
 

docs/src/InvariantTheory/tori.md

@@ -41,12 +41,12 @@ invariant_ring(r::RepresentationTorusGroup)
 ## Fundamental Systems of Invariants
 
 ```@docs
-fundamental_invariants(RT::TorGrpInvRing)
+fundamental_invariants(RT::TorGroupInvarRing)
 ```
 
 
 ## Invariant Rings as Affine Algebras
 
 ```@docs
-affine_algebra(RT::TorGrpInvRing)
+affine_algebra(RT::TorGroupInvarRing)
 ```

experimental/InvariantTheory/src/InvariantTheory.jl

@@ -9,7 +9,7 @@ export LinearlyReductiveGroup
 export linearly_reductive_group
 export natural_representation
 export null_cone_ideal
-export RedGrpInvRing
+export RedGroupInvarRing
 export representation
 export RepresentationLinearlyReductiveGroup
 export representation_matrix
@@ -279,7 +279,7 @@ end
 ##########################
 #Invariant Rings of Reductive groups
 ##########################
-@attributes mutable struct RedGrpInvRing
+@attributes mutable struct RedGroupInvarRing
     field::Field
     poly_ring::MPolyDecRing #graded
 
@@ -289,7 +289,7 @@ end
     reynolds_operator::Function
 
     #Invariant ring of reductive group G (in representation R), no other input.
-    function RedGrpInvRing(R::RepresentationLinearlyReductiveGroup) #here G already contains information n and rep_mat
+    function RedGroupInvarRing(R::RepresentationLinearlyReductiveGroup) #here G already contains information n and rep_mat
         z = new()
         n = ncols(R.rep_mat)
         z.representation = R
@@ -302,7 +302,7 @@ end
     end
 
     #to compute invariant ring ring^G where G is the reductive group of R. 
-    function RedGrpInvRing(R::RepresentationLinearlyReductiveGroup, ring::MPolyDecRing)
+    function RedGroupInvarRing(R::RepresentationLinearlyReductiveGroup, ring::MPolyDecRing)
         n = ncols(R.rep_mat)
         n == ngens(ring) || error("The given polynomial ring is not compatible.")
         z = new()
@@ -336,7 +336,7 @@ graded multivariate polynomial ring in 3 variables over QQ
   under group action of SL2
 ```
 """
-invariant_ring(R::RepresentationLinearlyReductiveGroup) = RedGrpInvRing(R)
+invariant_ring(R::RepresentationLinearlyReductiveGroup) = RedGroupInvarRing(R)
 
 @doc raw"""
     invariant_ring(R::MPolyDecRing, r::RepresentationLinearlyReductiveGroup)
@@ -357,22 +357,22 @@ graded multivariate polynomial ring in 10 variables over QQ
   under group action of SL3
 ```
 """
-invariant_ring(ring::MPolyDecRing, R::RepresentationLinearlyReductiveGroup) = RedGrpInvRing(R, ring)
+invariant_ring(ring::MPolyDecRing, R::RepresentationLinearlyReductiveGroup) = RedGroupInvarRing(R, ring)
 
-@attr MPolyIdeal function null_cone_ideal(R::RedGrpInvRing)
+@attr MPolyIdeal function null_cone_ideal(R::RedGroupInvarRing)
     Z = R.representation
     I, _ = proj_of_image_ideal(group(Z), Z.rep_mat)
     return ideal(generators(Z.group, I, Z.rep_mat))
 end
 
-polynomial_ring(R::RedGrpInvRing) = R.poly_ring
-group(R::RedGrpInvRing) = R.group
-representation(R::RedGrpInvRing) = R.representation
+polynomial_ring(R::RedGroupInvarRing) = R.poly_ring
+group(R::RedGroupInvarRing) = R.group
+representation(R::RedGroupInvarRing) = R.representation
 
 
 
 @doc raw"""
-    fundamental_invariants(RG::RedGrpInvRing)
+    fundamental_invariants(RG::RedGroupInvarRing)
 
 Return a system of fundamental invariants for `RG`.
 
@@ -390,14 +390,14 @@ julia> fundamental_invariants(RG)
 
 ```
 """
-@attr function fundamental_invariants(z::RedGrpInvRing) #unable to use abstract type
+@attr function fundamental_invariants(z::RedGroupInvarRing) #unable to use abstract type
     R = z.representation
     I, M = proj_of_image_ideal(R.group, R.rep_mat)
     null_cone_ideal(z) = ideal(generators(R.group, I, R.rep_mat))
     return inv_generators(null_cone_ideal(z), R.group, z.poly_ring, M, z.reynolds_operator)
 end
 
-function Base.show(io::IO, R::RedGrpInvRing) 
+function Base.show(io::IO, R::RedGroupInvarRing) 
     io = pretty(io)
     println(io, "Invariant Ring of")
     println(io, Lowercase(), R.poly_ring)
@@ -596,7 +596,7 @@ function reynolds_operator(X::RepresentationLinearlyReductiveGroup, elem::MPolyR
 end
 
 @doc raw"""
-    reynolds_operator(RG::RedGrpInvRing, f::MPolyRingElem)
+    reynolds_operator(RG::RedGroupInvarRing, f::MPolyRingElem)
 
 Return the image of `f` under the Reynolds operator corresponding to `RG`.
 
@@ -614,7 +614,7 @@ 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)
+function reynolds_operator(R::RedGroupInvarRing, elem::MPolyRingElem)
     X = R.representation
     return reynolds_operator(X, elem)
 end
@@ -625,7 +625,7 @@ include("TorusInvariantsFast.jl")
 #####################Invariant rings as affine algebras
 
 @doc raw"""
-    affine_algebra(RG::RedGrpInvRing)
+    affine_algebra(RG::RedGroupInvarRing)
 
 Return the invariant ring `RG` as an affine algebra (this amounts to compute the algebra syzygies among the fundamental invariants of `RG`).
 
@@ -646,7 +646,7 @@ julia> A, AtoS = affine_algebra(RG)
 (Quotient of multivariate polynomial ring by ideal (0), Hom: A -> S)
 ```
 """
-@attr function affine_algebra(R::RedGrpInvRing)
+@attr function affine_algebra(R::RedGroupInvarRing)
    V = fundamental_invariants(R)
    s = length(V)
    weights_ = zeros(Int, s)

experimental/InvariantTheory/src/TorusInvariantsFast.jl

@@ -161,22 +161,22 @@ end
 #Setting up invariant ring for fast torus algorithm. 
 #####################
 
-@attributes mutable struct TorGrpInvRing
+@attributes mutable struct TorGroupInvarRing
     field::Field
     poly_ring::MPolyDecRing #graded
 
     group::TorusGroup
     representation::RepresentationTorusGroup
 
     #Invariant ring of reductive group G (in representation R), no other input.
-    function TorGrpInvRing(R::RepresentationTorusGroup) #here G already contains information n and rep_mat
+    function TorGroupInvarRing(R::RepresentationTorusGroup) #here G already contains information n and rep_mat
         n = length(weights(R))
         super_ring, _ = graded_polynomial_ring(field(group(R)), "X"=>1:n)
-        return TorGrpInvRing(R, super_ring)
+        return TorGroupInvarRing(R, super_ring)
     end
 
     #to compute invariant ring ring^G where G is the reductive group of R. 
-    function TorGrpInvRing(R::RepresentationTorusGroup, ring_::MPolyDecRing)
+    function TorGroupInvarRing(R::RepresentationTorusGroup, ring_::MPolyDecRing)
         z = new()
         n = length(weights(R))
         z.field = field(group(R))
@@ -206,10 +206,10 @@ Invariant Ring of
 graded multivariate polynomial ring in 4 variables over QQ under group action of torus of rank2
 ```
 """
-invariant_ring(R::RepresentationTorusGroup) = TorGrpInvRing(R)
+invariant_ring(R::RepresentationTorusGroup) = TorGroupInvarRing(R)
 
 @doc raw"""
-    polynomial_ring(RT::TorGrpInvRing)
+    polynomial_ring(RT::TorGroupInvarRing)
 
 # Examples
 ```jldoctest
@@ -218,10 +218,10 @@ Torus of rank 2
   over QQ
 ```
 """
-polynomial_ring(R::TorGrpInvRing) = R.poly_ring
+polynomial_ring(R::TorGroupInvarRing) = R.poly_ring
 
 @doc raw"""
-    group(RT::TorGrpInvRing)
+    group(RT::TorGroupInvarRing)
 
 # Examples
 ```jldoctest
@@ -230,10 +230,10 @@ Torus of rank 2
   over QQ
 ```
 """
-group(R::TorGrpInvRing) = R.group
+group(R::TorGroupInvarRing) = R.group
 
 @doc raw"""
-    representation(RT::TorGrpInvRing)
+    representation(RT::TorGroupInvarRing)
 
 # Examples
 ```jldoctest
@@ -242,10 +242,10 @@ Torus of rank 2
   over QQ
 ```
 """
-representation(R::TorGrpInvRing) = R.representation
+representation(R::TorGroupInvarRing) = R.representation
 
 @doc raw"""
-    fundamental_invariants(RT::TorGrpInvRing)
+    fundamental_invariants(RT::TorGroupInvarRing)
 
 Return a system of fundamental invariants for `RT`.
 
@@ -264,12 +264,12 @@ julia> fundamental_invariants(RT)
  X[2]^2*X[3]
 ```
 """
-@attr function fundamental_invariants(z::TorGrpInvRing)
+@attr function fundamental_invariants(z::TorGroupInvarRing)
     R = z.representation
     return torus_invariants_fast(weights(R), polynomial_ring(z))
 end
 
-function Base.show(io::IO, R::TorGrpInvRing) 
+function Base.show(io::IO, R::TorGroupInvarRing) 
     io = pretty(io)
     println(io, "Invariant Ring of")
     print(io, Lowercase(), R.poly_ring)
@@ -369,7 +369,7 @@ end
 #####################Invariant rings as affine algebras
 
 @doc raw"""
-    affine_algebra(RT::TorGrpInvRing)
+    affine_algebra(RT::TorGroupInvarRing)
 
 Return the invariant ring `RT` as an affine algebra (this amounts to compute the algebra syzygies among the fundamental invariants of `RT`).
 
@@ -394,7 +394,7 @@ julia> affine_algebra(RT)
 (Quotient of multivariate polynomial ring by ideal (-t[1]*t[3] + t[2]^2), Hom: quotient of multivariate polynomial ring -> graded multivariate polynomial ring)
 ```
 """
-@attr function affine_algebra(R::TorGrpInvRing)
+@attr function affine_algebra(R::TorGroupInvarRing)
    V = fundamental_invariants(R)
    s = length(V)
    weights_ = zeros(Int, s)