Enhance inference in LieAlgebras, GSets, and MatrixGroups

Project.toml

@@ -25,7 +25,7 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 cohomCalg_jll = "5558cf25-a90e-53b0-b813-cadaa3ae7ade"
 
 [compat]
-AbstractAlgebra = "0.43.1"
+AbstractAlgebra = "0.43.7"
 AlgebraicSolving = "0.8.0"
 Distributed = "1.6"
 GAP = "0.12.0"

docs/src/Groups/action.md

@@ -61,7 +61,7 @@ action_function(Omega::GSetByElements)
 action_homomorphism(Omega::GSetByElements{T}) where T<:GAPGroup
 is_conjugate(Omega::GSet, omega1, omega2)
 is_conjugate_with_data(Omega::GSet, omega1, omega2)
-orbit(Omega::GSetByElements{<:GAPGroup}, omega::T) where T
+orbit(Omega::GSetByElements{<:GAPGroup, S}, omega::S) where S
 orbit(G::PermGroup, omega)
 orbits(Omega::T) where T <: GSetByElements{TG} where TG <: GAPGroup
 ```

experimental/LieAlgebras/src/AbstractLieAlgebra.jl

@@ -218,9 +218,15 @@
 function lie_algebra(
   basis::Vector{AbstractLieAlgebraElem{C}}; check::Bool=true
 ) where {C<:FieldElem}
-  parent_L = parent(basis[1])
-  @req all(parent(x) === parent_L for x in basis) "Elements not compatible."
-  R = coefficient_ring(parent_L)
+  @req !isempty(basis) "Basis must not be empty, or provide the Lie algebra as first argument"
+  return lie_algebra(parent(basis[1]), basis; check)
+end
+
+function lie_algebra(
+  L::AbstractLieAlgebra{C}, basis::Vector{AbstractLieAlgebraElem{C}}; check::Bool=true
+) where {C<:FieldElem}
+  @req all(parent(x) === L for x in basis) "Elements not compatible."
+  R = coefficient_ring(L)
   basis_matrix = if length(basis) == 0
     matrix(R, 0, dim(L), C[])
   else
@@ -370,9 +376,11 @@
       i < j || continue
       alpha_i_plus_beta_j = add!(alpha_i_plus_beta_j, alpha_i, beta_j)
       is_positive_root(alpha_i_plus_beta_j) || continue
-      l = findfirst(
-        l -> is_positive_root(alpha_i_plus_beta_j - simple_root(rs, l)), 1:nsimp
-      )::Int
+      l = let alpha_i_plus_beta_j = alpha_i_plus_beta_j # avoid closure capture
+        findfirst(
+          l -> is_positive_root(alpha_i_plus_beta_j - simple_root(rs, l)), 1:nsimp
+        )::Int
+      end
       l == i && continue # already extraspecial
       fl, l_comp = is_positive_root_with_index(alpha_i_plus_beta_j - simple_root(rs, l))
       @assert fl

experimental/LieAlgebras/src/LieAlgebra.jl

@@ -158,21 +158,21 @@ function (L::LieAlgebra)()
 end
 
 @doc raw"""
-    (L::LieAlgebra{C})(v::Vector{Int}) -> LieAlgebraElem{C}
+    (L::LieAlgebra{C})(v::AbstractVector{Int}) -> LieAlgebraElem{C}
 
 Return the element of `L` with coefficient vector `v`.
 Fail, if `Int` cannot be coerced into the base ring of `L`.
 """
-function (L::LieAlgebra)(v::Vector{Int})
+function (L::LieAlgebra)(v::AbstractVector{Int})
   return L(coefficient_ring(L).(v))
 end
 
 @doc raw"""
-    (L::LieAlgebra{C})(v::Vector{C}) -> LieAlgebraElem{C}
+    (L::LieAlgebra{C})(v::AbstractVector{C}) -> LieAlgebraElem{C}
 
 Return the element of `L` with coefficient vector `v`.
 """
-function (L::LieAlgebra{C})(v::Vector{C}) where {C<:FieldElem}
+function (L::LieAlgebra{C})(v::AbstractVector{C}) where {C<:FieldElem}
   @req length(v) == dim(L) "Length of vector does not match dimension."
   mat = matrix(coefficient_ring(L), 1, length(v), v)
   return elem_type(L)(L, mat)
@@ -291,7 +291,7 @@ end
 Return the center of `L`, i.e. $\{x \in L \mid [x, L] = 0\}$
 """
 function center(L::LieAlgebra)
-  dim(L) == 0 && return ideal(L, [])
+  dim(L) == 0 && return ideal(L, elem_type(L)[])
 
   mat = zero_matrix(coefficient_ring(L), dim(L), dim(L)^2)
   for (i, bi) in enumerate(basis(L))
@@ -300,9 +300,8 @@ function center(L::LieAlgebra)
     end
   end
 
-  c_basis = kernel(mat; side=:left)
-  c_dim = nrows(c_basis)
-  return ideal(L, [L(c_basis[i, :]) for i in 1:c_dim]; is_basis=true)
+  ker = kernel(mat; side=:left)
+  return ideal(L, L.(eachrow(ker)); is_basis=true)
 end
 
 @doc raw"""
@@ -548,7 +547,7 @@ function engel_subalgebra(x::LieAlgebraElem{C}) where {C<:FieldElem}
   n = dim(L)
   A = adjoint_matrix(x)^n
   ker = kernel(A; side=:left)
-  basis = [L(ker[i, :]) for i in 1:nrows(ker)]
+  basis = L.(eachrow(ker))
   L0adx = sub(L, basis; is_basis=true)
   return L0adx
 end
@@ -610,7 +609,7 @@ function _root_system_and_chevalley_basis(
       for (f, k) in facs
         @assert k == 1 # TODO: is this always the case?
         ker = kernel((f^k)(A); side=:left)
-        basis = [B_j(ker[i, :]) for i in 1:nrows(ker)]
+        basis = B_j.(eachrow(ker))
         push!(B_new, sub(L, basis; is_basis=true))
       end
     end

experimental/LieAlgebras/src/LieAlgebraIdeal.jl

@@ -99,21 +99,21 @@
 end
 
 @doc raw"""
-    (I::LieAlgebraIdeal{C})(v::Vector{Int}) -> LieAlgebraElem{C}
+    (I::LieAlgebraIdeal{C})(v::AbstractVector{Int}) -> LieAlgebraElem{C}
 
 Return the element of `I` with coefficient vector `v`.
 Fail, if `Int` cannot be coerced into the base ring of `I`.
 """
-function (I::LieAlgebraIdeal)(v::Vector{Int})
+function (I::LieAlgebraIdeal)(v::AbstractVector{Int})
   return I(coefficient_ring(I).(v))
 end
 
 @doc raw"""
-    (I::LieAlgebraIdeal{C})(v::Vector{C}) -> LieAlgebraElem{C}
+    (I::LieAlgebraIdeal{C})(v::AbstractVector{C}) -> LieAlgebraElem{C}
 
 Return the element of `I` with coefficient vector `v`.
 """
-function (I::LieAlgebraIdeal{C})(v::Vector{C}) where {C<:FieldElem}
+function (I::LieAlgebraIdeal{C})(v::AbstractVector{C}) where {C<:FieldElem}
   @req length(v) == dim(I) "Length of vector does not match dimension."
   mat = matrix(coefficient_ring(I), 1, length(v), v)
   L = base_lie_algebra(I)
@@ -268,8 +268,8 @@
 where `L` is the Lie algebra where `I` lives in.
 """
 function lie_algebra(I::LieAlgebraIdeal)
-  LI = lie_algebra(basis(I))
   L = base_lie_algebra(I)
+  LI = lie_algebra(L, basis(I))
   emb = hom(LI, L, basis(I); check=false)
   return LI, emb
 end

experimental/LieAlgebras/src/LieAlgebraModule.jl

@@ -252,21 +252,21 @@ function (V::LieAlgebraModule)()
 end
 
 @doc raw"""
-    (V::LieAlgebraModule{C})(v::Vector{Int}) -> LieAlgebraModuleElem{C}
+    (V::LieAlgebraModule{C})(v::AbstractVector{Int}) -> LieAlgebraModuleElem{C}
 
 Return the element of `V` with coefficient vector `v`.
 Fails, if `Int` cannot be coerced into the base ring of `L`.
 """
-function (V::LieAlgebraModule)(v::Vector{Int})
+function (V::LieAlgebraModule)(v::AbstractVector{Int})
   return V(coefficient_ring(V).(v))
 end
 
 @doc raw"""
-    (V::LieAlgebraModule{C})(v::Vector{C}) -> LieAlgebraModuleElem{C}
+    (V::LieAlgebraModule{C})(v::AbstractVector{C}) -> LieAlgebraModuleElem{C}
 
 Return the element of `V` with coefficient vector `v`.
 """
-function (V::LieAlgebraModule{C})(v::Vector{C}) where {C<:FieldElem}
+function (V::LieAlgebraModule{C})(v::AbstractVector{C}) where {C<:FieldElem}
   @req length(v) == dim(V) "Length of vector does not match dimension."
   mat = matrix(coefficient_ring(V), 1, length(v), v)
   return elem_type(V)(V, mat)

experimental/LieAlgebras/src/LieSubalgebra.jl

@@ -97,21 +97,21 @@
 end
 
 @doc raw"""
-    (S::LieSubalgebra{C})(v::Vector{Int}) -> LieAlgebraElem{C}
+    (S::LieSubalgebra{C})(v::AbstractVector{Int}) -> LieAlgebraElem{C}
 
 Return the element of `S` with coefficient vector `v`.
 Fail, if `Int` cannot be coerced into the base ring of `S`.
 """
-function (S::LieSubalgebra)(v::Vector{Int})
+function (S::LieSubalgebra)(v::AbstractVector{Int})
   return S(coefficient_ring(S).(v))
 end
 
 @doc raw"""
-    (S::LieSubalgebra{C})(v::Vector{C}) -> LieAlgebraElem{C}
+    (S::LieSubalgebra{C})(v::AbstractVector{C}) -> LieAlgebraElem{C}
 
 Return the element of `S` with coefficient vector `v`.
 """
-function (S::LieSubalgebra{C})(v::Vector{C}) where {C<:FieldElem}
+function (S::LieSubalgebra{C})(v::AbstractVector{C}) where {C<:FieldElem}
   @req length(v) == dim(S) "Length of vector does not match dimension."
   mat = matrix(coefficient_ring(S), 1, length(v), v)
   L = base_lie_algebra(S)
@@ -299,8 +299,8 @@
 where `L` is the Lie algebra where `S` lives in.
 """
 function lie_algebra(S::LieSubalgebra)
-  LS = lie_algebra(basis(S))
   L = base_lie_algebra(S)
+  LS = lie_algebra(L, basis(S))
   emb = hom(LS, L, basis(S); check=false)
   return LS, emb
 end

experimental/LieAlgebras/src/LinearLieAlgebra.jl

@@ -202,12 +202,17 @@
 function lie_algebra(
   basis::Vector{LinearLieAlgebraElem{C}}; check::Bool=true
 ) where {C<:FieldElem}
-  parent_L = parent(basis[1])
-  @req all(parent(x) === parent_L for x in basis) "Elements not compatible."
-  R = coefficient_ring(parent_L)
-  n = parent_L.n
+  @req !isempty(basis) "Basis must not be empty, or provide the Lie algebra as first argument"
+  return lie_algebra(parent(basis[1]), basis; check)
+end
+
+function lie_algebra(
+  L::LinearLieAlgebra{C}, basis::Vector{LinearLieAlgebraElem{C}}; check::Bool=true
+) where {C<:FieldElem}
+  @req all(parent(x) === L for x in basis) "Elements not compatible."
+  R = coefficient_ring(L)
   s = map(AbstractAlgebra.obj_to_string_wrt_times, basis)
-  return lie_algebra(R, n, matrix_repr.(basis), s; check)
+  return lie_algebra(R, L.n, matrix_repr.(basis), s; check)
 end
 
 @doc raw"""

experimental/LieAlgebras/src/RootSystem.jl

@@ -1238,8 +1238,8 @@ function dominant_weights(T::Type, R::RootSystem, hw::Vector{<:IntegerUnion})
 end
 
 function dominant_weights(
-  T::Type{<:Vector{<:IntegerUnion}}, R::RootSystem, hw::WeightLatticeElem
-)
+  ::Type{T}, R::RootSystem, hw::WeightLatticeElem
+) where {T<:Vector{<:IntegerUnion}}
   weights = dominant_weights(WeightLatticeElem, R, hw)
   return [T(_vec(coefficients(w))) for w in weights]
 end

experimental/LieAlgebras/src/Types.jl

@@ -295,7 +295,7 @@ end
     L::LieAlgebra{C}, gens::Vector{LieT}; is_basis::Bool=false
   ) where {C<:FieldElem,LieT<:LieAlgebraElem{C}}
     @req all(g -> parent(g) === L, gens) "Parent mismatch."
-    L::parent_type(LieT)
+    @req L isa parent_type(LieT) "Parent type mismatch."
     if is_basis
       basis_elems = gens
       basis_matrix = if length(gens) == 0
@@ -311,14 +311,14 @@ end
       while !isempty(left)
         g = pop!(left)
         can_solve(basis_matrix, _matrix(g); side=:left) && continue
-        for i in 1:nrows(basis_matrix)
-          push!(left, g * L(basis_matrix[i, :]))
+        for row in eachrow(basis_matrix)
+          push!(left, g * L(row))
         end
         basis_matrix = vcat(basis_matrix, _matrix(g))
         rank = rref!(basis_matrix)
-        basis_matrix = basis_matrix[1:rank, :]
+        @assert rank == nrows(basis_matrix) # otherwise the continue above would've triggered
       end
-      basis_elems = [L(basis_matrix[i, :]) for i in 1:nrows(basis_matrix)]
+      basis_elems = L.(eachrow(basis_matrix))
       return new{C,LieT}(L, gens, basis_elems, basis_matrix)
     end
   end
@@ -364,9 +364,9 @@ end
         end
         basis_matrix = vcat(basis_matrix, _matrix(g))
         rank = rref!(basis_matrix)
-        basis_matrix = basis_matrix[1:rank, :]
+        @assert rank == nrows(basis_matrix) # otherwise the continue above would've triggered
       end
-      basis_elems = [L(basis_matrix[i, :]) for i in 1:nrows(basis_matrix)]
+      basis_elems = L.(eachrow(basis_matrix))
       return new{C,LieT}(L, gens, basis_elems, basis_matrix)
     end
   end

src/GAP/iso_oscar_gap.jl

@@ -591,7 +591,7 @@ function AbstractAlgebra.map_entries(f::Map{T, GapObj}, a::MatrixElem{S}) where
    @assert base_ring(a) === domain(f)
    rows = Vector{GapObj}(undef, nrows(a))
    for i in 1:nrows(a)
-      rows[i] = GapObj([f(a[i, j]) for j in 1:ncols(a)])
+      rows[i] = GapObj([f(a[i, j])::GAP.Obj for j in 1:ncols(a)])
    end
    return GAPWrap.ImmutableMatrix(codomain(f), GapObj(rows), true)
 end

src/GAP/wrappers.jl

@@ -107,6 +107,8 @@ GAP.@wrap GeneratorsOfGroup(x::GapObj)::GapObj
 GAP.@wrap GetFusionMap(x::GapObj, y::GapObj)::GapObj
 GAP.@wrap GF(x::Any)::GapObj
 GAP.@wrap GF(x::Any, y::Any)::GapObj
+GAP.@wrap Group(x::GapObj)::GapObj
+GAP.@wrap Group(x::GapObj, y::GapObj)::GapObj
 GAP.@wrap GroupHomomorphismByFunction(x1, x2, x3)::GapObj
 GAP.@wrap GroupHomomorphismByFunction(x1, x2, x3, x4)::GapObj
 GAP.@wrap GroupHomomorphismByFunction(x1, x2, x3, x4, x5)::GapObj

src/Groups/gsets.jl

@@ -345,15 +345,15 @@ julia> length(orbit(Omega, 1))
 4
 ```
 """
-function orbit(Omega::GSetByElements{<:GAPGroup}, omega::T) where T
+function orbit(Omega::GSetByElements{<:GAPGroup, S}, omega::S) where S
     G = acting_group(Omega)
     acts = GapObj(gens(G))
     gfun = GapObj(action_function(Omega))
 
     # The following works only because GAP does not check
     # whether the given (dummy) group 'GapObj(G)' fits to the given generators,
     # or whether the elements of 'acts' are group elements.
-    orb = Vector{T}(GAP.Globals.Orbit(GapObj(G), omega, acts, acts, gfun)::GapObj)
+    orb = Vector{S}(GAP.Globals.Orbit(GapObj(G), omega, acts, acts, gfun)::GapObj)
 
     res = as_gset(acting_group(Omega), action_function(Omega), orb)
     # We know that this G-set is transitive.
@@ -413,7 +413,8 @@ julia> map(collect, orbs)
 """
 @attr Vector{GSetByElements{T,S}} function orbits(Omega::GSetByElements{T,S}) where {T <: Union{GAPGroup, FinGenAbGroup},S}
   orbs = GSetByElements{T,S}[]
-  for p in Omega.seeds
+  for p_ in Omega.seeds
+    p = p_::S
     if all(o -> !(p in o), orbs)
       push!(orbs, orbit(Omega, p))
     end