LieAlgebras: Introduce WeightLattice

experimental/BasisLieHighestWeight/src/BasisLieHighestWeight.jl

@@ -5,7 +5,6 @@ using ..Oscar: IntegerUnion
 using ..Oscar: _is_weighted
 
 using Oscar.LieAlgebras:
-  _character,
   _root_system_type_string,
   lie_algebra_simple_module_struct_consts_gap
 

experimental/BasisLieHighestWeight/src/MainAlgorithm.jl

@@ -43,7 +43,7 @@ function basis_lie_highest_weight_compute(
 
   # save computations from recursions
   calc_highest_weight = Dict{WeightLatticeElem,Set{ZZMPolyRingElem}}(
-    zero(WeightLatticeElem, R) => Set([ZZx(1)])
+    zero(weight_lattice(R)) => Set([ZZx(1)])
   )
   # save all highest weights, for which the Minkowski-sum did not suffice to gain all monomials
   no_minkowski = Set{WeightLatticeElem}()
@@ -98,7 +98,7 @@ function basis_coordinate_ring_kodaira_compute(
 
   # save computations from recursions
   calc_highest_weight = Dict{WeightLatticeElem,Set{ZZMPolyRingElem}}(
-    zero(WeightLatticeElem, R) => Set([ZZx(1)])
+    zero(weight_lattice(R)) => Set([ZZx(1)])
   )
 
   # save all highest weights, for which the Minkowski-sum did not suffice to gain all monomials
@@ -362,12 +362,12 @@ function add_by_hand(
   matrices_of_operators = tensor_matrices_of_operators(
     L, highest_weight, operators_as_roots(birational_seq)
   )
-  space = Dict(zero(WeightLatticeElem, R) => sparse_matrix(QQ)) # span of basis vectors to keep track of the basis
+  space = Dict(zero(weight_lattice(R)) => sparse_matrix(QQ)) # span of basis vectors to keep track of the basis
   v0 = sparse_row(ZZ, [(1, 1)])  # starting vector v
 
   push!(basis, ZZx(1))
   # required monomials of each weightspace
-  weightspaces = _character(R, highest_weight)
+  weightspaces = character(R, highest_weight)
   # sort the monomials from the minkowski-sum by their weightspaces
   monomials_in_weightspace = Dict{WeightLatticeElem,Set{ZZMPolyRingElem}}()
   for (weight_w, _) in weightspaces

experimental/BasisLieHighestWeight/test/MainAlgorithm-test.jl

@@ -36,7 +36,7 @@ end
   sub_weights_proper = BasisLieHighestWeight.sub_weights_proper
   R = root_system(:B, 3)
 
-  w_zero = zero(WeightLatticeElem, R)
+  w_zero = zero(weight_lattice(R))
   @test issetequal(sub_weights(w_zero), [w_zero])
   @test isempty(sub_weights_proper(w_zero))
 

experimental/LieAlgebras/docs/doc.main

@@ -8,6 +8,7 @@
       "module_homs.md",
       "cartan_matrix.md",
       "root_systems.md",
+      "weight_lattices.md",
       "weyl_groups.md",
    ],
 ]

experimental/LieAlgebras/docs/src/root_systems.md

@@ -10,8 +10,7 @@ Root systems in this module are meant to be abstract root systems, i.e. they are
 The relevant types around root systems are:
 - `RootSystem` for the root system itself,
 - `RootSpaceElem` for elements in the root space, i.e. roots and linear combinations thereof,
-- `DualRootSpaceElem` for elements in the dual root space, i.e. coroots and linear combinations thereof,
-- `WeightLatticeElem` for elements in the weight lattice, i.e. weights and linear combinations thereof.
+- `DualRootSpaceElem` for elements in the dual root space, i.e. coroots and linear combinations thereof.
 
 !!! warning
     Most functionality around root systems is currently only intended to be used with root systems of finite type.
@@ -46,6 +45,7 @@ rank(::RootSystem)
 cartan_matrix(::RootSystem)
 ```
 ```@docs; canonical=false
+weight_lattice(::RootSystem)
 weyl_group(::RootSystem)
 ```
 
@@ -180,44 +180,3 @@ is_positive_coroot_with_index(::DualRootSpaceElem)
 is_negative_coroot(::DualRootSpaceElem)
 is_negative_coroot_with_index(::DualRootSpaceElem)
 ```
-
-
-## Weight lattice elements
-
-```@docs
-WeightLatticeElem(::RootSystem, ::Vector{<:IntegerUnion})
-WeightLatticeElem(::RootSystem, ::ZZMatrix)
-WeightLatticeElem(::RootSpaceElem)
-zero(::Type{WeightLatticeElem}, ::RootSystem)
-```
-
-```@docs
-root_system(::WeightLatticeElem)
-```
-
-Basic arithmetic operations like `zero`, `+`, `-`, `*` (with integer scalars), and `==` are supported.
-
-```@docs
-coeff(::WeightLatticeElem, ::Int)
-coefficients(::WeightLatticeElem)
-```
-
-```@docs
-iszero(::WeightLatticeElem)
-is_dominant(::WeightLatticeElem)
-is_fundamental_weight(::WeightLatticeElem)
-is_fundamental_weight_with_index(::WeightLatticeElem)
-```
-
-### Reflections
-```@docs
-reflect(::WeightLatticeElem, ::Int)
-reflect!(::WeightLatticeElem, ::Int)
-```
-
-### Conjugate dominant weight
-```@docs
-conjugate_dominant_weight(::WeightLatticeElem)
-conjugate_dominant_weight_with_left_elem(::WeightLatticeElem)
-conjugate_dominant_weight_with_right_elem(::WeightLatticeElem)
-```

experimental/LieAlgebras/docs/src/weight_lattices.md

@@ -0,0 +1,75 @@
+```@meta
+CurrentModule = Oscar
+DocTestSetup = Oscar.doctestsetup()
+```
+
+# Weight lattices
+
+Weight lattices are represented by objects of type `WeightLattice <: AdditiveGroup`, and their elements by `WeightLatticeElem <: AdditiveGroupElement`.
+
+They are introduced to have a formal parent object of all weights that correspond to a common given root system.
+
+
+## Table of contents
+
+```@contents
+Pages = ["weight_lattices.md"]
+Depth = 2:5
+```
+
+## Constructing weight lattices
+```@docs
+weight_lattice(::RootSystem)
+```
+
+
+## Properties of weight lattices
+
+```@docs
+rank(::WeightLattice)
+is_finite(::WeightLattice)
+zero(::WeightLattice)
+gen(::WeightLattice, ::Int)
+gens(::WeightLattice)
+```
+
+```@docs
+root_system(::WeightLattice)
+```
+
+
+## Weight lattice elements
+
+```@docs
+WeightLatticeElem(::WeightLattice, ::Vector{<:IntegerUnion})
+WeightLatticeElem(::RootSystem, ::Vector{<:IntegerUnion})
+WeightLatticeElem(::WeightLattice, ::ZZMatrix)
+WeightLatticeElem(::RootSystem, ::ZZMatrix)
+WeightLatticeElem(::RootSpaceElem)
+```
+
+Basic arithmetic operations like `zero`, `+`, `-`, `*` (with integer scalars), and `==` are supported.
+
+```@docs
+coeff(::WeightLatticeElem, ::Int)
+coefficients(::WeightLatticeElem)
+```
+
+```@docs
+iszero(::WeightLatticeElem)
+is_dominant(::WeightLatticeElem)
+is_fundamental_weight(::WeightLatticeElem)
+is_fundamental_weight_with_index(::WeightLatticeElem)
+```
+
+### Reflections
+```@docs
+reflect(::WeightLatticeElem, ::Int)
+reflect!(::WeightLatticeElem, ::Int)
+```
+
+### Conjugate dominant weight
+```@docs
+conjugate_dominant_weight(::WeightLatticeElem)
+conjugate_dominant_weight_with_elem(::WeightLatticeElem)
+```

experimental/LieAlgebras/docs/src/weyl_groups.md

@@ -7,6 +7,12 @@ DocTestSetup = Oscar.doctestsetup()
 
 Weyl groups are represented by objects of type `WeylGroup <: Group`, and their elements by `WeylGroupElem <: GroupElement`.
 
+!!! warning
+    Weyl groups in OSCAR afford both left and right actions on roots and weights.
+    Note however, that **the left action** is the default (to align with the literature),
+    and all more complex functionality is defined with respect to the left action, e.g.
+    [`conjugate_dominant_weight_with_elem(::WeightLatticeElem)`](@ref).
+
 ## Table of contents
 
 ```@contents