Experimental: Add BasisLieHighestWeight

experimental/BasisLieHighestWeight/docs/doc.main

@@ -0,0 +1,3 @@
+[
+   "introduction.md"
+]

experimental/BasisLieHighestWeight/docs/src/introduction.md

@@ -0,0 +1,25 @@
+```@meta
+CurrentModule = Oscar
+DocTestSetup = quote
+  using Oscar
+end
+```
+
+# Introduction
+
+This subproject contains the code for the OSCAR book chapter by Ghislain Fourier and Xin Fang on the bases of highest weight modules.
+
+## Status
+
+This part of OSCAR is in an experimental state; please see [Adding new projects to experimental](@ref) for what this means.
+More documentation is to come in the future.
+
+## Contact
+
+Please direct questions about this part of OSCAR to the following people:
+* [Ghislain Fourier](https://www.art.rwth-aachen.de/cms/~rnko/)
+* [Lars Göttgens](https://lgoe.li/)
+
+You can ask questions in the [OSCAR Slack](https://www.oscar-system.org/community/#slack).
+
+Alternatively, you can [raise an issue on github](https://www.oscar-system.org/community/#how-to-report-issues).

experimental/BasisLieHighestWeight/src/BasisLieHighestWeight.jl

@@ -0,0 +1,59 @@
+module BasisLieHighestWeight
+
+using ..Oscar
+using ..Oscar: GAPWrap, IntegerUnion, _is_weighted
+
+using AbstractAlgebra.PrettyPrinting
+
+import Oscar: dim, monomial_ordering, monomials
+
+import Base: length
+
+# TODO: Test if ZZx should be a graded_polynomial_ring with weights_w as weights
+
+# TODO (?) Maybe export and docstring: 
+# get_dim_weightspace
+# orbit_weylgroup
+# get_lattice_points_of_weightspace
+# convert_lattice_points_to_monomials
+# convert_monomials_to_lattice_points
+# action_matrices_of_operators
+# weights_for_operators
+
+# TODO Use Oscar-Lie-Algebra type instead of LieAlgebra
+# TODO Data-Type for weights of Lie-Algebras? Two types, in alpha_i and w_i, conversion is defined in RootConversion
+# w_to_aplha
+# alpha_to_w
+
+# TODO GAPWrap-wrappers are missing
+
+include("LieAlgebras.jl")
+include("BirationalSequence.jl")
+include("MonomialBasis.jl")
+include("NewMonomial.jl")
+include("TensorModels.jl")
+include("MonomialOrder.jl")
+include("RootConversion.jl")
+include("WeylPolytope.jl")
+include("MainAlgorithm.jl")
+include("UserFunctions.jl")
+
+export basis_lie_highest_weight_operators
+export basis_lie_highest_weight
+export basis_lie_highest_weight_lusztig
+export basis_lie_highest_weight_nz
+export basis_lie_highest_weight_pbw
+export basis_lie_highest_weight_string
+
+end
+
+using .BasisLieHighestWeight
+
+export BasisLieHighestWeight
+
+export basis_lie_highest_weight_operators
+export basis_lie_highest_weight
+export basis_lie_highest_weight_lusztig
+export basis_lie_highest_weight_nz
+export basis_lie_highest_weight_pbw
+export basis_lie_highest_weight_string

experimental/BasisLieHighestWeight/src/BirationalSequence.jl

@@ -0,0 +1,12 @@
+struct BirationalSequence
+  operators::Vector{GAP.Obj}
+  operators_vectors::Vector{Vector{Any}}
+  weights_w::Vector{Vector{ZZRingElem}}
+  weights_alpha::Vector{Vector{QQFieldElem}}
+end
+
+function Base.show(io::IO, birational_sequence::BirationalSequence)
+  println(io, "BirationalSequence")
+  println(io, "Operators: ", birational_sequence.operators)
+  print(io, "Weights in alpha_i:", birational_sequence.weights_alpha)
+end

experimental/BasisLieHighestWeight/src/LieAlgebras.jl

@@ -0,0 +1,83 @@
+@attributes mutable struct LieAlgebraStructure
+  lie_type::Symbol
+  rank::Int
+  lie_algebra_gap::GAP.Obj
+  chevalley_basis::NTuple{3,Vector{GAP.Obj}}
+
+  function LieAlgebraStructure(lie_type::Symbol, rank::Int)
+    lie_algebra_gap = GAP.Globals.SimpleLieAlgebra(
+      GAP.Obj(lie_type), rank, GAP.Globals.Rationals
+    )
+    chevalley_basis = NTuple{3,Vector{GAP.Obj}}(GAP.Globals.ChevalleyBasis(lie_algebra_gap))
+    return new(lie_type, rank, lie_algebra_gap, chevalley_basis)
+  end
+end
+
+rank(L::LieAlgebraStructure) = L.rank
+
+@attr QQMatrix function cartan_matrix(L::LieAlgebraStructure)
+  R = GAP.Globals.RootSystem(L.lie_algebra_gap)
+  C = matrix(QQ, GAP.Globals.CartanMatrix(R))
+  return C
+end
+
+@attr QQMatrix function inv_cartan_matrix(L::LieAlgebraStructure)
+  return inv(cartan_matrix(L))
+end
+
+function Base.show(io::IO, L::LieAlgebraStructure)
+  io = pretty(io)
+  print(io, LowercaseOff(), "Lie algebra of type $(L.lie_type)$(L.rank)")
+end
+
+function lie_algebra(type::Symbol, rk::Int)
+  return LieAlgebraStructure(type, rk)
+end
+
+function chevalley_basis_gap(L::LieAlgebraStructure)
+  return L.chevalley_basis
+end
+
+function cartan_sub_basis(L::LieAlgebraStructure)
+  return L.chevalley_basis[3]
+end
+
+function root_system_gap(L::LieAlgebraStructure)
+  return GAP.Globals.RootSystem(L.lie_algebra_gap)
+end
+
+function num_positive_roots(L::LieAlgebraStructure)
+  return length(GAP.Globals.PositiveRoots(root_system_gap(L)))
+end
+
+function matrices_of_operators_gap(
+  L::LieAlgebraStructure, highest_weight::Vector{ZZRingElem}, operators::Vector{GAP.Obj}
+)
+  """
+  used to create action_matrices_of_operators
+  """
+  M = GAP.Globals.HighestWeightModule(L.lie_algebra_gap, GAP.Obj(Int.(highest_weight)))
+  matrices_of_operators = [
+    sparse_matrix(transpose(matrix(QQ, GAP.Globals.MatrixOfAction(GAPWrap.Basis(M), o)))) # TODO: remove transpose?
+    for o in operators
+  ]
+  denominators = map(y -> denominator(y[2]), union(union(matrices_of_operators...)...))
+  common_denominator = lcm(denominators)# // 1
+  matrices_of_operators =
+    (A -> change_base_ring(ZZ, common_denominator * A)).(matrices_of_operators)
+  return matrices_of_operators
+end
+
+function weight(L::LieAlgebraStructure, operator::GAP.Obj)
+  """
+  Calculates the weight in w_i for operator
+  """
+  @req !iszero(operator) "Operators should be non-zero"
+  basis = GAP.Globals.Basis(L.lie_algebra_gap)
+  basis_ind = GAP.Globals.Position(basis, operator)
+  denom = GAP.Globals.Coefficients(basis, operator)[basis_ind]
+  return [
+    ZZ(GAP.Globals.Coefficients(basis, h * operator)[basis_ind]//denom) for
+    h in cartan_sub_basis(L)
+  ]
+end