From 858ed06dbcf1b7fa7d38aa6e4069add18fe27456 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Thu, 31 Aug 2023 11:46:24 +0200 Subject: [PATCH] Refactor type variables in smash product and deformation (#134) --- src/DeformationBases/ArcDiagDeformBasis.jl | 26 ++-- .../PseudographDeformBasis.jl | 6 +- src/DeformationBases/StdDeformBasis.jl | 4 +- src/PBWDeformations.jl | 8 +- src/SmashProductLie.jl | 102 ++++++++++------ src/SmashProductLieDeform.jl | 111 ++++++++++++------ src/SmashProductPBWDeformLie.jl | 14 +-- test/SmashProductLie-test.jl | 12 +- test/SmashProductLieDeform-test.jl | 28 +++-- test/SmashProductPBWDeformLie-test.jl | 2 +- 10 files changed, 192 insertions(+), 121 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index b81b572d..5a8dfcdf 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -15,9 +15,9 @@ struct ArcDiagDeformBasis{C <: RingElem} <: DeformBasis{C} degs::AbstractVector{Int}; no_normalize::Bool=false, ) where {C <: RingElem} - @req get_attribute(lie_algebra(sp), :type, nothing) == :special_orthogonal "Only works for so_n." - @req (is_exterior_power(lie_module(sp)) || is_symmetric_power(lie_module(sp))) && - is_standard_module(base_module(lie_module(sp))) "Only works for exterior powers of the standard module." + @req get_attribute(base_lie_algebra(sp), :type, nothing) == :special_orthogonal "Only works for so_n." + @req (is_exterior_power(base_module(sp)) || is_symmetric_power(base_module(sp))) && + is_standard_module(base_module(base_module(sp))) "Only works for exterior powers of the standard module." extra_data = Dict{DeformationMap{C}, Set{ArcDiagram}}() normalize = no_normalize ? identity : normalize_default @@ -26,7 +26,7 @@ struct ArcDiagDeformBasis{C <: RingElem} <: DeformBasis{C} iters = [] debug_counter = 0 for d in degs - diag_iter = pbw_arc_diagrams__so(lie_module(sp), d) + diag_iter = pbw_arc_diagrams__so(base_module(sp), d) len = length(diag_iter) iter = ( begin @@ -184,31 +184,31 @@ end function arcdiag_to_deformationmap__so(diag::ArcDiagramUndirected, sp::SmashProductLie{C}) where {C <: RingElem} # TODO: allow for genereal ArcDiagrams d = div(n_lower_vertices(diag), 2) - dim_stdmod_V = lie_algebra(sp).n + dim_stdmod_V = base_lie_algebra(sp).n - e = arc_diagram_num_points__so(lie_module(sp)) + e = arc_diagram_num_points__so(base_module(sp)) iso_wedge2V_g = Dict{Vector{Int}, Int}() - for (i, bs) in enumerate(combinations(lie_algebra(sp).n, 2)) + for (i, bs) in enumerate(combinations(base_lie_algebra(sp).n, 2)) iso_wedge2V_g[bs] = i end index = Dict{Vector{Int}, Int}() - for (i, is) in enumerate(arc_diagram_label_iterator__so(lie_module(sp), 1:dim_stdmod_V)) + for (i, is) in enumerate(arc_diagram_label_iterator__so(base_module(sp), 1:dim_stdmod_V)) index[is] = i end - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) - for is in arc_diagram_label_iterator__so(lie_module(sp), 1:dim_stdmod_V), - js in arc_diagram_label_iterator__so(lie_module(sp), 1:dim_stdmod_V) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) + for is in arc_diagram_label_iterator__so(base_module(sp), 1:dim_stdmod_V), + js in arc_diagram_label_iterator__so(base_module(sp), 1:dim_stdmod_V) i = index[is] j = index[js] if i >= j continue end - for (is, sgn_left) in arc_diagram_label_permutations__so(lie_module(sp), is), - (js, sgn_right) in arc_diagram_label_permutations__so(lie_module(sp), js), + for (is, sgn_left) in arc_diagram_label_permutations__so(base_module(sp), is), + (js, sgn_right) in arc_diagram_label_permutations__so(base_module(sp), js), swap in [false, true] sgn_upper_labels = sgn_left * sgn_right diff --git a/src/DeformationBases/PseudographDeformBasis.jl b/src/DeformationBases/PseudographDeformBasis.jl index fbc13b0e..8389b6fe 100644 --- a/src/DeformationBases/PseudographDeformBasis.jl +++ b/src/DeformationBases/PseudographDeformBasis.jl @@ -16,10 +16,10 @@ struct PseudographDeformBasis{C <: RingElem} <: DeformBasis{C} degs::AbstractVector{Int}; no_normalize::Bool=false, ) where {C <: RingElem} - @req get_attribute(lie_algebra(sp), :type, nothing) == :special_orthogonal "Only works for so_n." - @req is_exterior_power(lie_module(sp)) && is_standard_module(base_module(lie_module(sp))) "Only works for exterior powers of the standard module." + @req get_attribute(base_lie_algebra(sp), :type, nothing) == :special_orthogonal "Only works for so_n." + @req is_exterior_power(base_module(sp)) && is_standard_module(base_module(base_module(sp))) "Only works for exterior powers of the standard module." - e = get_attribute(lie_module(sp), :power) + e = get_attribute(base_module(sp), :power) extra_data = Dict{DeformationMap{C}, Set{Tuple{PseudographLabelled{Int}, Partition{Int}}}}() normalize = no_normalize ? identity : normalize_default diff --git a/src/DeformationBases/StdDeformBasis.jl b/src/DeformationBases/StdDeformBasis.jl index 7af2b591..a96f67b4 100644 --- a/src/DeformationBases/StdDeformBasis.jl +++ b/src/DeformationBases/StdDeformBasis.jl @@ -11,8 +11,8 @@ struct StdDeformBasis{C <: RingElem} <: DeformBasis{C} normalize function StdDeformBasis{C}(sp::SmashProductLie{C}, degs::AbstractVector{Int}) where {C <: RingElem} - dimL = dim(lie_algebra(sp)) - dimV = dim(lie_module(sp)) + dimL = dim(base_lie_algebra(sp)) + dimV = dim(base_module(sp)) iter = ( begin kappa = fill(zero(underlying_algebra(sp)), dimV, dimV) diff --git a/src/PBWDeformations.jl b/src/PBWDeformations.jl index fc2ee204..56ac2fe8 100644 --- a/src/PBWDeformations.jl +++ b/src/PBWDeformations.jl @@ -2,6 +2,8 @@ module PBWDeformations using Oscar +using Oscar: IntegerUnion + using Oscar.LieAlgebras: AbstractLieAlgebra, AbstractLieAlgebraElem, @@ -12,7 +14,6 @@ using Oscar.LieAlgebras: LinearLieAlgebra, LinearLieAlgebraElem, abstract_module, - base_lie_algebra, combinations, exterior_power, general_linear_lie_algebra, @@ -36,7 +37,7 @@ import AbstractAlgebra: ProductIterator, coefficient_ring, elem_type, gen, gens, import Oscar: comm, edges, nedges, neighbors, nvertices, simplify, vertices -import Oscar.LieAlgebras: lie_algebra +import Oscar.LieAlgebras: base_lie_algebra, base_module import Base: deepcopy_internal, hash, isequal, isone, iszero, length, one, parent, show, sum, zero @@ -64,6 +65,7 @@ export all_pbwdeformations export all_pseudographs export arc_diagram export base_lie_algebra +export base_module export deform export edge_labels export edges @@ -74,8 +76,6 @@ export inneighbor export inneighbors export is_crossing_free export is_pbwdeformation -export lie_algebra -export lie_module export lookup_data export lower_vertex, is_lower_vertex export lower_vertices diff --git a/src/SmashProductLie.jl b/src/SmashProductLie.jl index 3d33805d..f08e7216 100644 --- a/src/SmashProductLie.jl +++ b/src/SmashProductLie.jl @@ -3,37 +3,37 @@ The struct representing a Lie algebra smash product. It consists of the underlying FreeAssAlgebra with relations and some metadata. It gets created by calling [`smash_product`](@ref). """ -@attributes mutable struct SmashProductLie{C <: RingElem, CL <: RingElem} <: NCRing +@attributes mutable struct SmashProductLie{C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} <: NCRing coeff_ring::Ring - L::LieAlgebra{CL} - V::LieAlgebraModule{CL} + L::LieAlgebra{LieC} + V::LieAlgebraModule{LieC} alg::FreeAssAlgebra{C} rels::Matrix{Union{Nothing, FreeAssAlgElem{C}}} # default constructor for @attributes - function SmashProductLie{C, CL}( + function SmashProductLie{C, LieC, LieT}( coeff_ring::Ring, - L::LieAlgebra{CL}, - V::LieAlgebraModule{CL}, + L::LieAlgebra{LieC}, + V::LieAlgebraModule{LieC}, alg::FreeAssAlgebra{C}, rels::Matrix{Union{Nothing, FreeAssAlgElem{C}}}, - ) where {C <: RingElem, CL <: RingElem} - new{C, CL}(coeff_ring, L, V, alg, rels) + ) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} + new{C, LieC, LieT}(coeff_ring, L, V, alg, rels) end end -mutable struct SmashProductLieElem{C <: RingElem, CL <: RingElem} <: NCRingElem - p::SmashProductLie{C, CL} # parent +mutable struct SmashProductLieElem{C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} <: NCRingElem + p::SmashProductLie{C, LieC, LieT} # parent alg_elem::FreeAssAlgElem{C} simplified::Bool function SmashProductLieElem( - p::SmashProductLie{C, CL}, + p::SmashProductLie{C, LieC, LieT}, alg_elem::FreeAssAlgElem{C}; simplified::Bool=false, - ) where {C <: RingElem, CL <: RingElem} + ) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} @req underlying_algebra(p) === parent(alg_elem) "Incompatible algebras." - return new{C, CL}(p, alg_elem, simplified) + return new{C, LieC, LieT}(p, alg_elem, simplified) end end @@ -43,33 +43,43 @@ end # ############################################################################### -parent_type(::Type{SmashProductLieElem{C, CL}}) where {C <: RingElem, CL <: RingElem} = SmashProductLie{C, CL} +parent_type( + ::Type{SmashProductLieElem{C, LieC, LieT}}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLie{C, LieC, LieT} -elem_type(::Type{SmashProductLie{C, CL}}) where {C <: RingElem, CL <: RingElem} = SmashProductLieElem{C, CL} +elem_type( + ::Type{SmashProductLie{C, LieC, LieT}}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLieElem{C, LieC, LieT} parent(e::SmashProductLieElem) = e.p -coefficient_ring(Sp::SmashProductLie) = Sp.coeff_ring +coefficient_ring( + Sp::SmashProductLie{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = Sp.coeff_ring::parent_type(C) coefficient_ring(e::SmashProductLieElem) = coefficient_ring(parent(e)) -lie_algebra(Sp::SmashProductLie) = Sp.L +base_lie_algebra( + Sp::SmashProductLie{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = Sp.L::parent_type(LieT) -lie_module(Sp::SmashProductLie) = Sp.V +base_module(Sp::SmashProductLie{C, LieC, LieT}) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = + Sp.V::LieAlgebraModule{LieC} underlying_algebra(Sp::SmashProductLie) = Sp.alg ngens(Sp::SmashProductLie) = ngens(underlying_algebra(Sp)) function ngens(Sp::SmashProductLie, part::Symbol) - part == :L && return dim(lie_algebra(Sp)) - part == :V && return dim(lie_module(Sp)) + part == :L && return dim(base_lie_algebra(Sp)) + part == :V && return dim(base_module(Sp)) error("Invalid part.") end gens(Sp::SmashProductLie) = map(Sp, gens(underlying_algebra(Sp))) function gens(Sp::SmashProductLie, part::Symbol) - part == :L && return [Sp(gen(underlying_algebra(Sp), i)) for i in 1:dim(lie_algebra(Sp))] - part == :V && return [Sp(gen(underlying_algebra(Sp), i + dim(lie_algebra(Sp)))) for i in 1:dim(lie_module(Sp))] + part == :L && return [Sp(gen(underlying_algebra(Sp), i)) for i in 1:dim(base_lie_algebra(Sp))] + part == :V && + return [Sp(gen(underlying_algebra(Sp), i + dim(base_lie_algebra(Sp)))) for i in 1:dim(base_module(Sp))] error("Invalid part.") end @@ -77,7 +87,7 @@ gen(Sp::SmashProductLie, i::Int) = Sp(gen(underlying_algebra(Sp), i)) function gen(Sp::SmashProductLie, i::Int, part::Symbol) @req 1 <= i <= ngens(Sp, part) "Invalid generator index." part == :L && return Sp(gen(underlying_algebra(Sp), i)) - part == :V && return Sp(gen(underlying_algebra(Sp), i + dim(lie_algebra(Sp)))) + part == :V && return Sp(gen(underlying_algebra(Sp), i + dim(base_lie_algebra(Sp)))) error("Invalid part.") end @@ -101,7 +111,10 @@ function Base.deepcopy_internal(e::SmashProductLieElem, dict::IdDict) return SmashProductLieElem(parent(e), deepcopy_internal(e.alg_elem, dict); simplified=e.simplified) end -function check_parent(e1::SmashProductLieElem{C}, e2::SmashProductLieElem{C}) where {C <: RingElem} +function check_parent( + e1::SmashProductLieElem{C, LieC, LieT}, + e2::SmashProductLieElem{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} parent(e1) != parent(e2) && error("Incompatible smash products.") end @@ -111,16 +124,16 @@ end # ############################################################################### -function show(io::IO, Sp::SmashProductLie{C, CL}) where {C <: RingElem, CL <: RingElem} +function show(io::IO, Sp::SmashProductLie{C, LieC}) where {C <: RingElem, LieC <: RingElem} print(io, "Smash Product") - if CL != C + if LieC != C print(io, " over ") print(IOContext(io, :supercompact => true), coefficient_ring(underlying_algebra(Sp))) end print(io, " of ") - print(IOContext(io, :compact => true), lie_algebra(Sp)) + print(IOContext(io, :compact => true), base_lie_algebra(Sp)) print(io, " and ") - print(IOContext(io, :compact => true), lie_module(Sp)) + print(IOContext(io, :compact => true), base_module(Sp)) end @@ -143,14 +156,16 @@ function (Sp::SmashProductLie)(e::Union{RingElement, NCRingElem}) return Sp(underlying_algebra(Sp)(e)) end -function (Sp::SmashProductLie{C, CL})(e::FreeAssAlgElem{C}) where {C <: RingElem, CL <: RingElem} +function (Sp::SmashProductLie{C})(e::FreeAssAlgElem{C}) where {C <: RingElem} if underlying_algebra(Sp) !== parent(e) e = underlying_algebra(Sp)(e) end return SmashProductLieElem(Sp, e) end -function (Sp::SmashProductLie{C, CL})(e::SmashProductLieElem{C, CL}) where {C <: RingElem, CL <: RingElem} +function (Sp::SmashProductLie{C, LieC, LieT})( + e::SmashProductLieElem{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} @req parent(e) == Sp "Incompatible smash products." return e end @@ -165,17 +180,17 @@ function Base.:-(e::SmashProductLieElem) return parent(e)(-e.alg_elem) end -function Base.:+(e1::SmashProductLieElem{C}, e2::SmashProductLieElem{C}) where {C <: RingElem} +function Base.:+(e1::SmashProductLieElem, e2::SmashProductLieElem) check_parent(e1, e2) return parent(e1)(e1.alg_elem + e2.alg_elem) end -function Base.:-(e1::SmashProductLieElem{C}, e2::SmashProductLieElem{C}) where {C <: RingElem} +function Base.:-(e1::SmashProductLieElem, e2::SmashProductLieElem) check_parent(e1, e2) return parent(e1)(e1.alg_elem - e2.alg_elem) end -function Base.:*(e1::SmashProductLieElem{C}, e2::SmashProductLieElem{C}) where {C <: RingElem} +function Base.:*(e1::SmashProductLieElem, e2::SmashProductLieElem) check_parent(e1, e2) return parent(e1)(e1.alg_elem * e2.alg_elem) end @@ -185,7 +200,11 @@ function Base.:*(e::SmashProductLieElem{C}, c::C) where {C <: RingElem} return parent(e)(e.alg_elem * c) end -function Base.:*(e::SmashProductLieElem{C}, c::U) where {C <: RingElem, U <: Union{Rational, Integer}} +function Base.:*(e::SmashProductLieElem, c::U) where {U <: Union{Rational, IntegerUnion}} + return parent(e)(e.alg_elem * c) +end + +function Base.:*(e::SmashProductLieElem{ZZRingElem}, c::ZZRingElem) return parent(e)(e.alg_elem * c) end @@ -194,7 +213,11 @@ function Base.:*(c::C, e::SmashProductLieElem{C}) where {C <: RingElem} return parent(e)(c * e.alg_elem) end -function Base.:*(c::U, e::SmashProductLieElem{C}) where {C <: RingElem, U <: Union{Rational, Integer}} +function Base.:*(c::U, e::SmashProductLieElem) where {U <: Union{Rational, IntegerUnion}} + return parent(e)(c * e.alg_elem) +end + +function Base.:*(c::ZZRingElem, e::SmashProductLieElem{ZZRingElem}) return parent(e)(c * e.alg_elem) end @@ -202,7 +225,7 @@ function Base.:^(e::SmashProductLieElem, n::Int) return parent(e)(e.alg_elem^n) end -function comm(e1::SmashProductLieElem{C}, e2::SmashProductLieElem{C}) where {C <: RingElem} +function comm(e1::SmashProductLieElem, e2::SmashProductLieElem) check_parent(e1, e2) return parent(e1)(e1.alg_elem * e2.alg_elem - e2.alg_elem * e1.alg_elem) end @@ -213,7 +236,10 @@ end # ############################################################################### -function Base.:(==)(e1::SmashProductLieElem, e2::SmashProductLieElem) +function Base.:(==)( + e1::SmashProductLieElem{C, LieC, LieT}, + e2::SmashProductLieElem{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} return parent(e1) === parent(e2) && simplify(e1).alg_elem == simplify(e2).alg_elem end @@ -322,7 +348,7 @@ function smash_product(R::Ring, L::LieAlgebra{C}, V::LieAlgebraModule{C}) where rels[dimL+j, i] = f_basisL[i] * f_basisV[j] - commutator end - Sp = SmashProductLie{elem_type(R), C}(R, L, V, f_alg, rels) + Sp = SmashProductLie{elem_type(R), C, elem_type(L)}(R, L, V, f_alg, rels) return Sp end diff --git a/src/SmashProductLieDeform.jl b/src/SmashProductLieDeform.jl index 975841b0..feedcd00 100644 --- a/src/SmashProductLieDeform.jl +++ b/src/SmashProductLieDeform.jl @@ -3,33 +3,34 @@ The struct representing a deformation of a Lie algebra smash product. It consists of the underlying FreeAssAlgebra with relations and some metadata. It gets created by calling [`deform`](@ref). """ -@attributes mutable struct SmashProductLieDeform{C <: RingElem, CL <: RingElem} <: NCRing - sp::SmashProductLie{C, CL} +@attributes mutable struct SmashProductLieDeform{C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} <: + NCRing + sp::SmashProductLie{C, LieC, LieT} rels::Matrix{Union{Nothing, FreeAssAlgElem{C}}} kappa::DeformationMap{C} # default constructor for @attributes - function SmashProductLieDeform{C, CL}( - sp::SmashProductLie{C, CL}, + function SmashProductLieDeform{C, LieC, LieT}( + sp::SmashProductLie{C, LieC, LieT}, rels::Matrix{Union{Nothing, FreeAssAlgElem{C}}}, kappa::DeformationMap{C}, - ) where {C <: RingElem, CL <: RingElem} - new{C, CL}(sp, rels, kappa) + ) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} + new{C, LieC, LieT}(sp, rels, kappa) end end -mutable struct SmashProductLieDeformElem{C <: RingElem, CL <: RingElem} <: NCRingElem - p::SmashProductLieDeform{C, CL} # parent +mutable struct SmashProductLieDeformElem{C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} <: NCRingElem + p::SmashProductLieDeform{C, LieC, LieT} # parent alg_elem::FreeAssAlgElem{C} simplified::Bool function SmashProductLieDeformElem( - p::SmashProductLieDeform{C, CL}, + p::SmashProductLieDeform{C, LieC, LieT}, alg_elem::FreeAssAlgElem{C}; simplified::Bool=false, - ) where {C <: RingElem, CL <: RingElem} + ) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} @req underlying_algebra(p) === parent(alg_elem) "Incompatible algebras." - return new{C, CL}(p, alg_elem, simplified) + return new{C, LieC, LieT}(p, alg_elem, simplified) end end @@ -39,34 +40,43 @@ end # ############################################################################### -parent_type(::Type{SmashProductLieDeformElem{C, CL}}) where {C <: RingElem, CL <: RingElem} = - SmashProductLieDeform{C, CL} +arent_type( + ::Type{SmashProductLieDeformElem{C, LieC, LieT}}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLieDeform{C, LieC, LieT} -elem_type(::Type{SmashProductLieDeform{C, CL}}) where {C <: RingElem, CL <: RingElem} = SmashProductLieDeformElem{C, CL} +elem_type( + ::Type{SmashProductLieDeform{C, LieC, LieT}}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLieDeformElem{C, LieC, LieT} parent(e::SmashProductLieDeformElem) = e.p -coefficient_ring(D::SmashProductLieDeform) = coefficient_ring(D.sp) +coefficient_ring( + D::SmashProductLieDeform{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = coefficient_ring(D.sp)::parent_type(C) coefficient_ring(e::SmashProductLieDeformElem) = coefficient_ring(parent(e)) -lie_algebra(D::SmashProductLieDeform) = lie_algebra(D.sp) +base_lie_algebra( + D::SmashProductLieDeform{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = base_lie_algebra(D.sp)::parent_type(LieT) -lie_module(D::SmashProductLieDeform) = lie_module(D.sp) +base_module( + D::SmashProductLieDeform{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = base_module(D.sp)::LieAlgebraModule{LieC} underlying_algebra(D::SmashProductLieDeform) = underlying_algebra(D.sp) # TODO: create new algebra for D ngens(D::SmashProductLieDeform) = ngens(underlying_algebra(D)) function ngens(D::SmashProductLieDeform, part::Symbol) - part == :L && return dim(lie_algebra(D)) - part == :V && return dim(lie_module(D)) + part == :L && return dim(base_lie_algebra(D)) + part == :V && return dim(base_module(D)) error("Invalid part.") end gens(D::SmashProductLieDeform) = map(D, gens(underlying_algebra(D))) function gens(D::SmashProductLieDeform, part::Symbol) - part == :L && return [D(gen(underlying_algebra(D), i)) for i in 1:dim(lie_algebra(D))] - part == :V && return [D(gen(underlying_algebra(D), i + dim(lie_algebra(D)))) for i in 1:dim(lie_module(D))] + part == :L && return [D(gen(underlying_algebra(D), i)) for i in 1:dim(base_lie_algebra(D))] + part == :V && return [D(gen(underlying_algebra(D), i + dim(base_lie_algebra(D)))) for i in 1:dim(base_module(D))] error("Invalid part.") end @@ -74,7 +84,7 @@ gen(D::SmashProductLieDeform, i::Int) = D(gen(underlying_algebra(D), i)) function gen(D::SmashProductLieDeform, i::Int, part::Symbol) @req 1 <= i <= ngens(D, part) "Invalid generator index." part == :L && return D(gen(underlying_algebra(D), i)) - part == :V && return D(gen(underlying_algebra(D), i + dim(lie_algebra(D)))) + part == :V && return D(gen(underlying_algebra(D), i + dim(base_lie_algebra(D)))) error("Invalid part.") end @@ -98,7 +108,10 @@ function Base.deepcopy_internal(e::SmashProductLieDeformElem, dict::IdDict) return SmashProductLieDeformElem(parent(e), deepcopy_internal(e.alg_elem, dict); simplified=e.simplified) end -function check_parent(e1::SmashProductLieDeformElem{C}, e2::SmashProductLieDeformElem{C}) where {C <: RingElem} +function check_parent( + e1::SmashProductLieDeformElem{C, LieC, LieT}, + e2::SmashProductLieDeformElem{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} parent(e1) != parent(e2) && error("Incompatible smash product deformations.") end @@ -137,19 +150,23 @@ function (D::SmashProductLieDeform)(e::Union{RingElement, NCRingElem}) return D(underlying_algebra(D)(e)) end -function (D::SmashProductLieDeform{C, CL})(e::FreeAssAlgElem{C}) where {C <: RingElem, CL <: RingElem} +function (D::SmashProductLieDeform{C})(e::FreeAssAlgElem{C}) where {C <: RingElem} if underlying_algebra(D) !== parent(e) e = underlying_algebra(D)(e) end return SmashProductLieDeformElem(D, e) end -function (D::SmashProductLieDeform{C, CL})(e::SmashProductLieDeformElem{C, CL}) where {C <: RingElem, CL <: RingElem} +function (D::SmashProductLieDeform{C, LieC, LieT})( + e::SmashProductLieDeformElem{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} @req parent(e) == D "Incompatible smash product deformations." return e end -function (D::SmashProductLieDeform{C, CL})(e::SmashProductLieElem{C, CL}) where {C <: RingElem, CL <: RingElem} +function (D::SmashProductLieDeform{C, LieC, LieT})( + e::SmashProductLieElem{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} @req parent(e) == D.sp "Incompatible smash products." return D(e.alg_elem) end @@ -164,17 +181,17 @@ function Base.:-(e::SmashProductLieDeformElem) return parent(e)(-e.alg_elem) end -function Base.:+(e1::SmashProductLieDeformElem{C}, e2::SmashProductLieDeformElem{C}) where {C <: RingElem} +function Base.:+(e1::SmashProductLieDeformElem, e2::SmashProductLieDeformElem) check_parent(e1, e2) return parent(e1)(e1.alg_elem + e2.alg_elem) end -function Base.:-(e1::SmashProductLieDeformElem{C}, e2::SmashProductLieDeformElem{C}) where {C <: RingElem} +function Base.:-(e1::SmashProductLieDeformElem, e2::SmashProductLieDeformElem) check_parent(e1, e2) return parent(e1)(e1.alg_elem - e2.alg_elem) end -function Base.:*(e1::SmashProductLieDeformElem{C}, e2::SmashProductLieDeformElem{C}) where {C <: RingElem} +function Base.:*(e1::SmashProductLieDeformElem, e2::SmashProductLieDeformElem) check_parent(e1, e2) return parent(e1)(e1.alg_elem * e2.alg_elem) end @@ -184,7 +201,11 @@ function Base.:*(e::SmashProductLieDeformElem{C}, c::C) where {C <: RingElem} return parent(e)(e.alg_elem * c) end -function Base.:*(e::SmashProductLieDeformElem{C}, c::U) where {C <: RingElem, U <: Union{Rational, Integer}} +function Base.:*(e::SmashProductLieDeformElem, c::U) where {U <: Union{Rational, IntegerUnion}} + return parent(e)(e.alg_elem * c) +end + +function Base.:*(e::SmashProductLieDeformElem{ZZRingElem}, c::ZZRingElem) return parent(e)(e.alg_elem * c) end @@ -193,7 +214,11 @@ function Base.:*(c::C, e::SmashProductLieDeformElem{C}) where {C <: RingElem} return parent(e)(c * e.alg_elem) end -function Base.:*(c::U, e::SmashProductLieDeformElem{C}) where {C <: RingElem, U <: Union{Rational, Integer}} +function Base.:*(c::U, e::SmashProductLieDeformElem) where {U <: Union{Rational, IntegerUnion}} + return parent(e)(c * e.alg_elem) +end + +function Base.:*(c::ZZRingElem, e::SmashProductLieDeformElem{ZZRingElem}) return parent(e)(c * e.alg_elem) end @@ -201,7 +226,7 @@ function Base.:^(e::SmashProductLieDeformElem, n::Int) return parent(e)(e.alg_elem^n) end -function comm(e1::SmashProductLieDeformElem{C}, e2::SmashProductLieDeformElem{C}) where {C <: RingElem} +function comm(e1::SmashProductLieDeformElem, e2::SmashProductLieDeformElem) check_parent(e1, e2) return parent(e1)(e1.alg_elem * e2.alg_elem - e2.alg_elem * e1.alg_elem) end @@ -212,7 +237,10 @@ end # ############################################################################### -function Base.:(==)(e1::SmashProductLieDeformElem, e2::SmashProductLieDeformElem) +function Base.:(==)( + e1::SmashProductLieDeformElem{C, LieC, LieT}, + e2::SmashProductLieDeformElem{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} return parent(e1) === parent(e2) && simplify(e1).alg_elem == simplify(e2).alg_elem end @@ -250,9 +278,12 @@ Constructs the deformation of the smash product `sp` by the deformation map `kap Returns a [`SmashProductLieDeform`](@ref) struct and a two-part basis. """ -function deform(sp::SmashProductLie{C, CL}, kappa::DeformationMap{C}) where {C <: RingElem, CL <: RingElem} - dimL = dim(lie_algebra(sp)) - dimV = dim(lie_module(sp)) +function deform( + sp::SmashProductLie{C, LieC, LieT}, + kappa::DeformationMap{C}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} + dimL = dim(base_lie_algebra(sp)) + dimV = dim(base_module(sp)) @req size(kappa) == (dimV, dimV) "kappa has wrong dimensions." @@ -273,7 +304,7 @@ function deform(sp::SmashProductLie{C, CL}, kappa::DeformationMap{C}) where {C < symmetric &= iszero(kappa[i, j]) end - d = SmashProductLieDeform{C, CL}(sp, rels, kappa) + d = SmashProductLieDeform{C, LieC, LieT}(sp, rels, kappa) set_attribute!(d, :is_symmetric, symmetric) @@ -285,8 +316,10 @@ end Constructs the symmetric deformation of the smash product `sp`. """ -function symmetric_deformation(sp::SmashProductLie{C, CL}) where {C <: RingElem, CL <: RingElem} - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) +function symmetric_deformation( + sp::SmashProductLie{C, LieC, LieT}, +) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) d = deform(sp, kappa) return d end diff --git a/src/SmashProductPBWDeformLie.jl b/src/SmashProductPBWDeformLie.jl index 4a8876ff..c852ce6b 100644 --- a/src/SmashProductPBWDeformLie.jl +++ b/src/SmashProductPBWDeformLie.jl @@ -9,8 +9,8 @@ keyword arguments, e.g. `disabled = [:c, :d]`. function pbwdeform_eqs(d::SmashProductLieDeform; disabled::Vector{Symbol}=Symbol[]) # Uses Theorem 3.1 of Walton, Witherspoon: Poincare-Birkhoff-Witt deformations of smash product algebras from Hopf actions on Koszul algebras. # DOI: 10.2140/ant.2014.8.1701. https://arxiv.org/abs/1308.6011 - dimL = dim(lie_algebra(d)) - dimV = dim(lie_module(d)) + dimL = dim(base_lie_algebra(d)) + dimV = dim(base_module(d)) x(i) = gen(d, i, :L) v(i) = gen(d, i, :V) @@ -50,8 +50,8 @@ function pbwdeform_eqs(d::SmashProductLieDeform; disabled::Vector{Symbol}=Symbol end function pbwdeform_neqs(d::SmashProductLieDeform) - dimL = dim(lie_algebra(d)) - dimV = dim(lie_module(d)) + dimL = dim(base_lie_algebra(d)) + dimV = dim(base_module(d)) num_a = dimL * binomial(dimV, 2) num_b = 0 @@ -105,8 +105,8 @@ function all_pbwdeformations( ) where {C <: RingElem, T <: Union{Nothing, SMat}} @req coefficient_ring(sp) == QQ "Only implemented for QQ coefficients." - dimL = dim(lie_algebra(sp)) - dimV = dim(lie_module(sp)) + dimL = dim(base_lie_algebra(sp)) + dimV = dim(base_module(sp)) nvars = length(deform_basis) @@ -114,7 +114,7 @@ function all_pbwdeformations( R, vars = polynomial_ring(coefficient_ring(sp), max(nvars, 1)) @vprintln :PBWDeformations 1 "Changing SmashProductLie coeffcient type..." - new_sp = smash_product(R, lie_algebra(sp), lie_module(sp)) + new_sp = smash_product(R, base_lie_algebra(sp), base_module(sp)) @vprintln :PBWDeformations 1 "Constructing kappa..." kappa = fill(zero(underlying_algebra(new_sp)), dimV, dimV) diff --git a/test/SmashProductLie-test.jl b/test/SmashProductLie-test.jl index c42dc40a..ecfc6ae2 100644 --- a/test/SmashProductLie-test.jl +++ b/test/SmashProductLie-test.jl @@ -4,7 +4,11 @@ L = special_linear_lie_algebra(QQ, 2) V = standard_module(L) - sp = smash_product(L, V) + sp = smash_product(R, L, V) + + @test (@inferred coefficient_ring(sp)) == R + @test (@inferred base_lie_algebra(sp)) == L + @test (@inferred base_module(sp)) == V @test dim(L) == ngens(sp, :L) @test dim(L) == length(gens(sp, :L)) @@ -48,7 +52,11 @@ L = special_orthogonal_lie_algebra(QQ, 4) V = exterior_power(standard_module(L), 2) - sp = smash_product(L, V) + sp = smash_product(R, L, V) + + @test (@inferred coefficient_ring(sp)) == R + @test (@inferred base_lie_algebra(sp)) == L + @test (@inferred base_module(sp)) == V @test dim(L) == ngens(sp, :L) @test dim(L) == length(gens(sp, :L)) diff --git a/test/SmashProductLieDeform-test.jl b/test/SmashProductLieDeform-test.jl index 15b8ad97..598991d4 100644 --- a/test/SmashProductLieDeform-test.jl +++ b/test/SmashProductLieDeform-test.jl @@ -6,13 +6,17 @@ V = exterior_power(standard_module(L), 2) sp = smash_product(L, V) - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) kappa[1, 2] = gen(sp, 1, :L).alg_elem kappa[2, 1] = -kappa[1, 2] kappa[3, 4] = gen(sp, 2, :L).alg_elem kappa[4, 3] = -kappa[3, 4] d = deform(sp, kappa) + @test (@inferred coefficient_ring(d)) == R + @test (@inferred base_lie_algebra(d)) == L + @test (@inferred base_module(d)) == V + @test dim(L) == ngens(d, :L) @test dim(L) == length(gens(d, :L)) @test dim(L) == 6 @@ -102,54 +106,54 @@ @testset "check dimensions of kappa" begin for eps in [-1, 1] - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)) + eps, dim(lie_module(sp))) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)) + eps, dim(base_module(sp))) @test_throws ArgumentError("kappa has wrong dimensions.") deform(sp, kappa) - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp)) + eps) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp)) + eps) @test_throws ArgumentError("kappa has wrong dimensions.") deform(sp, kappa) - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)) + eps, dim(lie_module(sp)) + eps) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)) + eps, dim(base_module(sp)) + eps) @test_throws ArgumentError("kappa has wrong dimensions.") deform(sp, kappa) - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)) + eps, dim(lie_module(sp)) - eps) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)) + eps, dim(base_module(sp)) - eps) @test_throws ArgumentError("kappa has wrong dimensions.") deform(sp, kappa) end end @testset "check kappa is skew symmetric" begin - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) kappa[1, 1] = gen(sp, 1, :L) @test_throws ArgumentError("kappa is not skew-symmetric.") deform(sp, kappa) - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) kappa[1, 2] = gen(sp, 1, :L) @test_throws ArgumentError("kappa is not skew-symmetric.") deform(sp, kappa) - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) kappa[1, 2] = gen(sp, 1, :L) kappa[2, 1] = -2 * gen(sp, 1, :L) @test_throws ArgumentError("kappa is not skew-symmetric.") deform(sp, kappa) end @testset "check entries of kappa contained in Hopf algebra of smash product" begin - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) kappa[1, 2] = gen(sp, 1, :V) kappa[2, 1] = -kappa[1, 2] @test_throws ArgumentError("kappa does not only take values in the hopf algebra") deform(sp, kappa) - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) kappa[1, 2] = gen(sp, 1, :V) * gen(sp, 1, :L) kappa[2, 1] = -kappa[1, 2] @test_throws ArgumentError("kappa does not only take values in the hopf algebra") deform(sp, kappa) end @testset "correct input" begin - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) kappa[1, 2] = underlying_algebra(sp)(2) kappa[2, 1] = -kappa[1, 2] @test_nowarn deform(sp, kappa) - kappa = fill(zero(underlying_algebra(sp)), dim(lie_module(sp)), dim(lie_module(sp))) + kappa = fill(zero(underlying_algebra(sp)), dim(base_module(sp)), dim(base_module(sp))) kappa[1, 2] = gen(sp, 1, :L) * gen(sp, 2, :L) - 3 * gen(sp, 3, :L) kappa[2, 1] = -kappa[1, 2] @test_nowarn deform(sp, kappa) diff --git a/test/SmashProductPBWDeformLie-test.jl b/test/SmashProductPBWDeformLie-test.jl index f9f508f3..a5d0a6c9 100644 --- a/test/SmashProductPBWDeformLie-test.jl +++ b/test/SmashProductPBWDeformLie-test.jl @@ -41,7 +41,7 @@ @test length(basis) == 1 + div(maxdeg, 2) for b in basis - for i in 1:dim(lie_module(sp)), j in 1:dim(lie_module(sp)) + for i in 1:dim(base_module(sp)), j in 1:dim(base_module(sp)) @test iszero(b[i, j] + b[j, i]) end end