update docs

Author: vitktor

README.md

@@ -25,6 +25,7 @@ SO3 = LieGroup("SO", 3)
 a = MatrixGroupAction(SO3, [vars])
 V = FixedDegreePolynomials(vars, 2)
 ρ = GroupRepresentation(a, V)
+
 irrs = irreducibles(ρ)
 ```
 ```

docs/make.jl

@@ -17,11 +17,10 @@ makedocs(;
     pages=[
         "Introduction" => "index.md",
         "Reductive groups" => [
-            "Group types" => "groups/types.md",
+            "Types of groups" => "groups/types.md",
             "Finite groups" => "groups/finite.md",
             "Lie groups" => "groups/lie.md",
             "Direct products" => "groups/products.md",
-            "Group Elements" => "groups/elements.md",
         ],
         "Representations of reductive groups" => [
             "Vector spaces" => "representations/spaces.md",

docs/src/groups/elements.md

@@ -0,0 +1,3 @@
+# Finite groups
+
+TBW

docs/src/groups/finite.md

@@ -1,13 +1,19 @@
 # Lie groups
 
+The computations with Lie groups are done by passing to their associated Lie algebras. We distinguish between Lie groups that act by scalings (represented by [`ScalingLieGroup`](@ref)) and basic reductive matrix Lie groups, like ``\mathrm{SO}(n)`` (represented by [`LieGroup`](@ref)).
+
+## Lie groups
+
 ```@docs
-algebra(::AbstractGroup{Lie})
+ScalingLieGroup
+LieGroup
 ```
 
 ## Lie algebras
 
 ```@docs
 AbstractLieAlgebra
+algebra(::AbstractGroup{Lie})
 name(::AbstractLieAlgebra)
 basis(::AbstractLieAlgebra)
 chevalley_basis(::AbstractLieAlgebra)

docs/src/groups/lie.md

@@ -2,4 +2,5 @@
 
 ```@docs
 AbstractDirectProductGroup
+DirectProductGroup
 ```

docs/src/groups/products.md

@@ -1,14 +1,9 @@
-# Group types
-
-```@docs
-AbstractGroup
-```
-
-Each [`AbstractGroup`](@ref) has a [`GroupType`](@ref) that are described below.
+# Types of groups
 
 ```@docs
 GroupType
 Finite
 Lie
 Mixed
+AbstractGroup
 ```

docs/src/groups/types.md

@@ -58,6 +58,41 @@ function irreducibles(
     return [IrreducibleRepresentation(action(ρ), hwv) for hwv in hw_vectors]
 end
 
+# function irreducibles_old(
+#     ρ::GroupRepresentation{A, S}
+# ) where {T, F, A<:AbstractGroupAction{Lie}, S<:SymmetricPower{T, F, <:HighestWeightModule}}
+#     V = space(ρ)
+#     power(V) == 1 && return [IrreducibleRepresentation(action(ρ), base_space(V))]
+#     ws = weight_structure(base_space(V))
+#     sym_ws = sym(ws, power(V))
+#     println("old nweights: ", nweights(sym_ws))
+#     println("old sum of dims: ", sum([dim(space(sym_ws[w])) for w in weights(sym_ws)]))
+#     Xs = positive_root_elements(algebra(action(ρ)))
+#     hw_vectors = common_nullspace_as_weight_vectors(Xs, action(ρ), sym_ws)
+#     return [IrreducibleRepresentation(action(ρ), hwv) for hwv in hw_vectors]
+# end
+
+# function irreducibles_old(
+#     ρ::GroupRepresentation{A, T}
+# ) where {A<:AbstractGroupAction{Lie}, T<:SymmetricPower}
+#     V = space(ρ)
+#     ρ_base = GroupRepresentation(action(ρ), base_space(V))
+#     irreds_base = irreducibles(ρ_base)
+#     if length(irreds_base) == 1
+#         V = SymmetricPower(space(first(irreds_base)), power(V))
+#         ρᵢ = GroupRepresentation(action(ρ), V)
+#         return irreducibles_old(ρᵢ)
+#     end
+#     mexps = multiexponents(degree=power(V), nvars=length(irreds_base))
+#     irreds = IrreducibleRepresentation{A}[]
+#     for mexp in mexps
+#         Vᵢ = TensorProduct([SymmetricPower(space(irreds_base[idx]), val) for (val, idx) in zip(mexp.nzval, mexp.nzind)])
+#         ρᵢ = GroupRepresentation(action(ρ), Vᵢ)
+#         append!(irreds, irreducibles(ρᵢ))
+#     end
+#     return irreds
+# end
+
 function irreducibles(
     ρ::GroupRepresentation{A, S}
 ) where {T, F, A<:AbstractGroupAction{Lie}, S<:SymmetricPower{T, F, <:HighestWeightModule}}
@@ -71,41 +106,6 @@ function irreducibles(
     return [IrreducibleRepresentation(action(ρ), hwv) for hwv in hw_vectors]
 end
 
-function irreducibles_old(
-    ρ::GroupRepresentation{A, S}
-) where {T, F, A<:AbstractGroupAction{Lie}, S<:SymmetricPower{T, F, <:HighestWeightModule}}
-    V = space(ρ)
-    power(V) == 1 && return [IrreducibleRepresentation(action(ρ), base_space(V))]
-    ws = weight_structure(base_space(V))
-    sym_ws = sym(ws, power(V))
-    println("old nweights: ", nweights(sym_ws))
-    println("old sum of dims: ", sum([dim(space(sym_ws[w])) for w in weights(sym_ws)]))
-    Xs = positive_root_elements(algebra(action(ρ)))
-    hw_vectors = common_nullspace_as_weight_vectors(Xs, action(ρ), sym_ws)
-    return [IrreducibleRepresentation(action(ρ), hwv) for hwv in hw_vectors]
-end
-
-function irreducibles_old(
-    ρ::GroupRepresentation{A, T}
-) where {A<:AbstractGroupAction{Lie}, T<:SymmetricPower}
-    V = space(ρ)
-    ρ_base = GroupRepresentation(action(ρ), base_space(V))
-    irreds_base = irreducibles(ρ_base)
-    if length(irreds_base) == 1
-        V = SymmetricPower(space(first(irreds_base)), power(V))
-        ρᵢ = GroupRepresentation(action(ρ), V)
-        return irreducibles_old(ρᵢ)
-    end
-    mexps = multiexponents(degree=power(V), nvars=length(irreds_base))
-    irreds = IrreducibleRepresentation{A}[]
-    for mexp in mexps
-        Vᵢ = TensorProduct([SymmetricPower(space(irreds_base[idx]), val) for (val, idx) in zip(mexp.nzval, mexp.nzind)])
-        ρᵢ = GroupRepresentation(action(ρ), Vᵢ)
-        append!(irreds, irreducibles(ρᵢ))
-    end
-    return irreds
-end
-
 function irreducibles(
     ρ::GroupRepresentation{A, T}
 ) where {A<:AbstractGroupAction{Lie}, T<:SymmetricPower}

src/decompositions/irred-decomp.jl

@@ -14,6 +14,7 @@ struct ScalingLieAlgebra{F} <: AbstractLieAlgebra{F}
 end
 
 ScalingLieAlgebra{F}(size::Int) where F = ScalingLieAlgebra{F}("ℂ", sparse(ones(Int, 1, size)))
+ScalingLieAlgebra{F}(exps::Matrix{Int}) where F = ScalingLieAlgebra{F}("ℂ$(superscript(size(exps, 1)))", sparse(exps))
 
 name(alg::ScalingLieAlgebra) = alg.name
 dim(alg::ScalingLieAlgebra) = size(alg.exps, 1)
@@ -129,6 +130,7 @@ dim(alg::LieAlgebra) = length(alg.basis.std_basis)
 rank(alg::LieAlgebra) = length(alg.basis.cartan)
 Base.size(alg::LieAlgebra) = size(alg.basis.std_basis[1], 1)
 weight_type(::LieAlgebra{F, W}) where {F, W} = W
+weight_inner_type(::LieAlgebra{F, Weight{W}}) where {F, W} = W
 
 function Base.show(io::IO, alg::LieAlgebra{F, Weight{W}}; offset::Int=0) where {F, W}
     println(io, " "^offset, "LieAlgebra $(name(alg))")

src/lie-groups/lie-algebras/algebras.jl

@@ -4,19 +4,89 @@ export LieGroup,
     ×
 
 
+"""
+    ScalingLieGroup{F} <: AbstractGroup{Lie, F}
+
+Represents a scaling Lie group. The group elements are diagonal matrices.
+
+# Constructors
+```julia
+ScalingLieGroup{F}(size::Int) where F
+ScalingLieGroup{F}(exps::Matrix{Int}) where F
+```
+
+# Examples
+```jldoctest
+julia> ScalingLieGroup{ComplexF64}(5)
+ScalingLieGroup ℂˣ
+ number type (or field): ComplexF64
+ Lie algebra properties:
+  dimension: 1
+  basis (diagonal matrices):
+   [1, 1, 1, 1, 1]
+```
+```jldoctest
+julia> exps = [1 1 1 0 0 0; 0 0 0 1 -2 0];
+
+julia> ScalingLieGroup{ComplexF64}(exps)
+ScalingLieGroup (ℂˣ)²
+ number type (or field): ComplexF64
+ Lie algebra properties:
+  dimension: 2
+  basis (diagonal matrices):
+   [1, 1, 1, 0, 0, 0]
+   [0, 0, 0, 1, -2, 0]
+```
+"""
 struct ScalingLieGroup{F} <: AbstractGroup{Lie, F}
     name::String
     algebra::ScalingLieAlgebra{F}
 end
 
 ScalingLieGroup{F}(size::Int) where F = ScalingLieGroup("ℂˣ", ScalingLieAlgebra{F}(size))
+function ScalingLieGroup{F}(exps::Matrix{Int}) where F
+    name = size(exps, 1) == 1 ? "ℂˣ" : "(ℂˣ)$(superscript(size(exps, 1)))"
+    ScalingLieGroup(name, ScalingLieAlgebra{F}(exps))
+end
 
 name(G::ScalingLieGroup) = G.name
 algebra(G::ScalingLieGroup) = G.algebra
 exponents(G::ScalingLieGroup) = exponents(algebra(G))
 weight(G::ScalingLieGroup, i::Integer) = Weight(Vector(exponents(G)[:, i]))
 
+function Base.show(io::IO, G::ScalingLieGroup{F}) where F
+    println(io, "ScalingLieGroup $(name(G))")
+    println(io, " number type (or field): $(F)")
+    println(io, " Lie algebra properties:")
+    println(io, "  dimension: $(dim(algebra(G)))")
+    println(io, "  basis (diagonal matrices):")
+    show_basis(io, algebra(G), offset=3)
+end
+
+
+"""
+    LieGroup{F} <: AbstractGroup{Lie, F}
+
+Describes a matrix Lie group.
 
+# Constructors
+```julia
+LieGroup(type::String, size::Int)
+```
+
+Supported Lie group types: SO (special orthogonal).
+
+# Examples
+```jldoctest
+julia> SO3 = LieGroup("SO", 3)
+LieGroup SO(3)
+ number type (or field): ComplexF64
+ weight type: Int64
+ Lie algebra properties:
+  dimension: 3
+  rank (dimension of Cartan subalgebra): 1
+```
+"""
 struct LieGroup{F, T <: LieAlgebra{F}} <: AbstractGroup{Lie, F}
     name::String
     algebra::T
@@ -39,11 +109,32 @@ end
 function Base.show(io::IO, G::LieGroup{F}) where F
     println(io, "LieGroup $(name(G))")
     println(io, " number type (or field): $(F)")
-    println(io, " Lie algebra:")
-    show(io, algebra(G); offset = 2)
+    println(io, " weight type: $(weight_inner_type(algebra(G)))")
+    println(io, " Lie algebra properties:")
+    println(io, "  dimension: $(dim(algebra(G)))")
+    print(io, "  rank (dimension of Cartan subalgebra): $(rank(algebra(G)))")
 end
 
-
+"""
+    DirectProductGroup{T<:GroupType, F} <: AbstractDirectProductGroup{T, F}
+
+Represents a direct product of groups.
+# Examples
+```jldoctest
+julia> SO3 = LieGroup("SO", 3);
+
+julia> T = ScalingLieGroup{ComplexF64}([1 2 3 4; -1 -2 -3 -4]);
+
+julia> SO3 × SO3 × T
+DirectProductLieGroup SO(3) × SO(3) × (ℂˣ)²
+ number type (or field): ComplexF64
+ 3 factors: SO(3), SO(3), (ℂˣ)²
+ Lie algebra:
+  SumLieAlgebra 𝖘𝖔(3) ⊕ 𝖘𝖔(3) ⊕ ℂ²
+  dimension: 8
+  rank (dimension of Cartan subalgebra): 4
+```
+"""
 struct DirectProductGroup{T<:GroupType, F, S<:AbstractGroup{T, F}} <: AbstractDirectProductGroup{T, F}
     name::String
     groups::Vector{S}
@@ -55,6 +146,7 @@ DirectProductGroup(
 
 name(G::DirectProductGroup) = G.name
 groups(G::DirectProductGroup) = G.groups
+ngroups(G::DirectProductGroup) = length(groups(G))
 algebra(G::DirectProductGroup) = SumLieAlgebra([algebra(Gᵢ) for Gᵢ in groups(G)])
 ×(
     G₁::AbstractGroup{Lie, F},
@@ -65,13 +157,17 @@ algebra(G::DirectProductGroup) = SumLieAlgebra([algebra(Gᵢ) for Gᵢ in groups
     G₂::AbstractGroup{Lie, F}
 ) where F = DirectProductGroup("$(name(G₁)) × $(name(G₂))", vcat(groups(G₁), [G₂]))
 
-function Base.show(io::IO, G::DirectProductGroup{F}) where F
+function Base.show(io::IO, G::DirectProductGroup{T, F}) where {T, F}
     println(io, "DirectProductLieGroup $(name(G))")
     println(io, " number type (or field): $(F)")
-    print(io, " Lie algebra:")
+    println(io, " $(ngroups(G)) factors: ", join([name(Gᵢ) for Gᵢ in groups(G)], ", "))
+    println(io, " Lie algebra:")
+    println(io, "  SumLieAlgebra $(name(algebra(G)))")
+    println(io, "  dimension: $(dim(algebra(G)))")
+    print(io, "  rank (dimension of Cartan subalgebra): $(rank(algebra(G)))")
 end
 
-
+# TODO: remove and use DirectProductGroup instead with a Mixed group type
 struct DirectProductMixedGroup{
     F, T <: AbstractGroup{Lie, F}, S <: AbstractGroup{Finite, F}
 } <: AbstractDirectProductGroup{Mixed, F}