From b833d028c7382ba965b277664982d0c95a040f03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 6 Feb 2024 12:09:20 +0100 Subject: [PATCH 01/13] Add `Val{:special_orthogonal}` to functions to enable better dispatch --- src/DeformationBases/ArcDiagDeformBasis.jl | 73 ++++++++++++------- .../PseudographDeformBasis.jl | 14 +++- test/DeformationBases-test.jl | 7 +- 3 files changed, 61 insertions(+), 33 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index 9990e85..092cce6 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -1,3 +1,5 @@ +const SO = Val{:special_orthogonal} + """ Concrete subtype of [`DeformBasis`](@ref). Each element of the basis is induced by an arc diagram of a suitable size, @@ -15,7 +17,17 @@ struct ArcDiagDeformBasis{C <: RingElem} <: DeformBasis{C} degs::AbstractVector{Int}; no_normalize::Bool=false, ) where {C <: RingElem} - @req get_attribute(base_lie_algebra(sp), :type, nothing) == :special_orthogonal "Only works for so_n." + T = get_attribute(base_lie_algebra(sp), :type, nothing) + @req T == :special_orthogonal "Only works for so_n." + return ArcDiagDeformBasis{C}(Val(T), sp, degs; no_normalize) + end + + function ArcDiagDeformBasis{C}( + T::Union{SO}, + sp::SmashProductLie{C}, + degs::AbstractVector{Int}; + no_normalize::Bool=false, + ) where {C <: RingElem} V = base_module(sp) V_nice, h = isomorphic_module_with_simple_structure(V) @@ -48,12 +60,12 @@ struct ArcDiagDeformBasis{C <: RingElem} <: DeformBasis{C} tensor_product(V_nice_summand_i_l, V_nice_summand_i_r) end - diag_iter = pbw_arc_diagrams__so(W, d) + diag_iter = pbw_arc_diagrams__so(T, W, d) len = length(diag_iter) iter = ( begin @vprintln :PBWDeformations 2 "Basis generation deg $(lpad(d, maximum(ndigits, degs))), $(lpad(floor(Int, 100*(debug_counter = (debug_counter % len) + 1) / len), 3))%, $(lpad(debug_counter, ndigits(len)))/$(len)" - _basis_elem = arcdiag_to_deformationmap__so(diag, sp, W) + _basis_elem = arcdiag_to_deformationmap__so(T, diag, sp, W) basis_elem = matrix(proj_to_summand_l) * _basis_elem * transpose(matrix(proj_to_summand_r)) if i_l != i_r basis_elem -= transpose(basis_elem) @@ -98,28 +110,28 @@ end Base.length(basis::ArcDiagDeformBasis) = basis.len -function pbw_arc_diagrams__so(V::LieAlgebraModule, d::Int) - n_upper_vertices = arc_diagram_num_points__so(V) +function pbw_arc_diagrams__so(T::SO, V::LieAlgebraModule, d::Int) + n_upper_vertices = arc_diagram_num_points__so(T, V) n_lower_vertices = 2d - upper_indep_sets = arc_diagram_indep_sets__so(V) + upper_indep_sets = arc_diagram_indep_sets__so(T, V) lower_indep_sets = Vector{Int}[[[2i - 1, 2i] for i in 1:div(n_lower_vertices, 2)]...] indep_sets = Vector{Int}[[(-1) .* is for is in upper_indep_sets]; [is for is in lower_indep_sets]] return all_arc_diagrams(Undirected, n_upper_vertices, n_lower_vertices; indep_sets) end -function arc_diagram_num_points__so(V::LieAlgebraModule) +function arc_diagram_num_points__so(T::SO, V::LieAlgebraModule) if is_standard_module(V) return 1 elseif is_tensor_product(V) - return sum(arc_diagram_num_points__so(W) for W in base_modules(V)) + return sum(arc_diagram_num_points__so(T, W) for W in base_modules(V)) elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) - return arc_diagram_num_points__so(base_module(V)) * get_attribute(V, :power) + return arc_diagram_num_points__so(T, base_module(V)) * get_attribute(V, :power) else error("Not implemented.") end end -function arc_diagram_indep_sets__so(V::LieAlgebraModule) +function arc_diagram_indep_sets__so(T::SO, V::LieAlgebraModule) if is_standard_module(V) return Vector{Int}[] elseif is_tensor_product(V) @@ -134,21 +146,21 @@ function arc_diagram_indep_sets__so(V::LieAlgebraModule) return Vector{Int}[] end else - iss = arc_diagram_indep_sets__so(inner_mod) - return [map(i -> i + k * arc_diagram_num_points__so(inner_mod), is) for k in 0:power-1 for is in iss] + iss = arc_diagram_indep_sets__so(T, inner_mod) + return [map(i -> i + k * arc_diagram_num_points__so(T, inner_mod), is) for k in 0:power-1 for is in iss] end else error("Not implemented.") end end -function arc_diagram_label_iterator__so(V::LieAlgebraModule, base_labels::AbstractVector{Int}) +function arc_diagram_label_iterator__so(T::SO, V::LieAlgebraModule, base_labels::AbstractVector{Int}) if is_standard_module(V) return [[l] for l in base_labels] elseif is_tensor_product(V) inner_mods = base_modules(V) return ProductIterator([ - arc_diagram_label_iterator__so(inner_mod, base_labels) for inner_mod in reverse(inner_mods) + arc_diagram_label_iterator__so(T, inner_mod, base_labels) for inner_mod in reverse(inner_mods) ]) .|> reverse .|> Iterators.flatten .|> @@ -156,19 +168,19 @@ function arc_diagram_label_iterator__so(V::LieAlgebraModule, base_labels::Abstra elseif is_exterior_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - return combinations(collect(arc_diagram_label_iterator__so(inner_mod, base_labels)), power) .|> + return combinations(collect(arc_diagram_label_iterator__so(T, inner_mod, base_labels)), power) .|> Iterators.flatten .|> collect elseif is_symmetric_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - return multicombinations(collect(arc_diagram_label_iterator__so(inner_mod, base_labels)), power) .|> + return multicombinations(collect(arc_diagram_label_iterator__so(T, inner_mod, base_labels)), power) .|> Iterators.flatten .|> collect elseif is_tensor_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - return ProductIterator(arc_diagram_label_iterator__so(inner_mod, base_labels), power) .|> + return ProductIterator(arc_diagram_label_iterator__so(T, inner_mod, base_labels), power) .|> reverse .|> Iterators.flatten .|> collect @@ -198,13 +210,13 @@ function basis_index_mapping(V::LieAlgebraModule) end end -function arc_diagram_label_permutations__so(V::LieAlgebraModule, label::AbstractVector{Int}) +function arc_diagram_label_permutations__so(T::SO, V::LieAlgebraModule, label::AbstractVector{Int}) if is_standard_module(V) @req length(label) == 1 "Number of labels mismatch." return [(label, 1)] elseif is_tensor_product(V) inner_mods = base_modules(V) - @req length(label) == sum(arc_diagram_num_points__so.(inner_mods)) "Number of labels mismatch." + @req length(label) == sum(mod -> arc_diagram_num_points__so(T, mod), inner_mods) "Number of labels mismatch." return [ begin inner_label = vcat(first.(inner_iter)...) @@ -212,9 +224,10 @@ function arc_diagram_label_permutations__so(V::LieAlgebraModule, label::Abstract (inner_label, inner_sign) end for inner_iter in ProductIterator([ arc_diagram_label_permutations__so( + T, inner_mod, - label[sum(arc_diagram_num_points__so, inner_mods[1:i-1]; init=0)+1:sum( - arc_diagram_num_points__so, + label[sum(mod -> arc_diagram_num_points__so(T, mod), inner_mods[1:i-1]; init=0)+1:sum( + mod -> arc_diagram_num_points__so(T, mod), inner_mods[1:i]; init=0, )], @@ -224,7 +237,7 @@ function arc_diagram_label_permutations__so(V::LieAlgebraModule, label::Abstract elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - m = arc_diagram_num_points__so(inner_mod) + m = arc_diagram_num_points__so(T, inner_mod) @req length(label) == m * power "Number of labels mismatch." if is_exterior_power(V) return [ @@ -233,7 +246,7 @@ function arc_diagram_label_permutations__so(V::LieAlgebraModule, label::Abstract inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign * outer_sign) end for (outer_perm, outer_sign) in permutations_with_sign(1:power) for inner_iter in ProductIterator([ - arc_diagram_label_permutations__so(inner_mod, label[(outer_perm[i]-1)*m+1:outer_perm[i]*m]) for + arc_diagram_label_permutations__so(T, inner_mod, label[(outer_perm[i]-1)*m+1:outer_perm[i]*m]) for i in 1:power ]) ] @@ -244,7 +257,7 @@ function arc_diagram_label_permutations__so(V::LieAlgebraModule, label::Abstract inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign) end for outer_perm in permutations(1:power) for inner_iter in ProductIterator([ - arc_diagram_label_permutations__so(inner_mod, label[(outer_perm[i]-1)*m+1:outer_perm[i]*m]) for + arc_diagram_label_permutations__so(T, inner_mod, label[(outer_perm[i]-1)*m+1:outer_perm[i]*m]) for i in 1:power ]) ] @@ -254,8 +267,9 @@ function arc_diagram_label_permutations__so(V::LieAlgebraModule, label::Abstract inner_label = vcat(first.(inner_iter)...) inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign) - end for inner_iter in - ProductIterator([arc_diagram_label_permutations__so(inner_mod, label[(i-1)*m+1:i*m]) for i in 1:power]) + end for inner_iter in ProductIterator([ + arc_diagram_label_permutations__so(T, inner_mod, label[(i-1)*m+1:i*m]) for i in 1:power + ]) ] else error("Unreachable.") @@ -267,6 +281,7 @@ end function arcdiag_to_deformationmap__so( + T::SO, diag::ArcDiagramUndirected, sp::SmashProductLie{C}, W::LieAlgebraModule=exterior_power(base_module(sp), 2), @@ -289,11 +304,12 @@ function arcdiag_to_deformationmap__so( end kappa = zero_matrix(underlying_algebra(sp), nrows_kappa, ncols_kappa) - for (label_index, upper_labels) in enumerate(arc_diagram_label_iterator__so(W, 1:dim_stdmod_V)) + for (label_index, upper_labels) in enumerate(arc_diagram_label_iterator__so(T, W, 1:dim_stdmod_V)) i, j = ind_map[label_index] entry = arcdiag_to_deformationmap_entry__so( + T, diag, W, upper_labels, @@ -313,6 +329,7 @@ function arcdiag_to_deformationmap__so( end function arcdiag_to_deformationmap_entry__so( + T::SO, diag::ArcDiagramUndirected, W::LieAlgebraModule{C}, upper_labels::AbstractVector{Int}, @@ -322,7 +339,7 @@ function arcdiag_to_deformationmap_entry__so( ) where {C <: RingElem} entry = zero(sp_alg) - for (upper_labels, sgn_upper_labels) in arc_diagram_label_permutations__so(W, upper_labels) + for (upper_labels, sgn_upper_labels) in arc_diagram_label_permutations__so(T, W, upper_labels) zeroprod = false lower_labels = [0 for _ in 1:n_lower_vertices(diag)] frees = Int[] diff --git a/src/DeformationBases/PseudographDeformBasis.jl b/src/DeformationBases/PseudographDeformBasis.jl index 8389b6f..0010b21 100644 --- a/src/DeformationBases/PseudographDeformBasis.jl +++ b/src/DeformationBases/PseudographDeformBasis.jl @@ -16,7 +16,17 @@ struct PseudographDeformBasis{C <: RingElem} <: DeformBasis{C} degs::AbstractVector{Int}; no_normalize::Bool=false, ) where {C <: RingElem} - @req get_attribute(base_lie_algebra(sp), :type, nothing) == :special_orthogonal "Only works for so_n." + T = get_attribute(base_lie_algebra(sp), :type, nothing) + @req T == :special_orthogonal "Only works for so_n." + return PseudographDeformBasis{C}(Val(T), sp, degs; no_normalize) + end + + function PseudographDeformBasis{C}( + T::Union{Val{:special_orthogonal}}, + sp::SmashProductLie{C}, + degs::AbstractVector{Int}; + no_normalize::Bool=false, + ) where {C <: RingElem} @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(base_module(sp), :power) @@ -34,7 +44,7 @@ struct PseudographDeformBasis{C <: RingElem} <: DeformBasis{C} begin @vprintln :PBWDeformations 2 "Basis generation deg $(lpad(d, maximum(ndigits, degs))), $(lpad(floor(Int, 100*(debug_counter = (debug_counter % len) + 1) / len), 3))%, $(lpad(debug_counter, ndigits(len)))/$(len)" diag = to_arcdiag(pg, part) - basis_elem = arcdiag_to_deformationmap__so(diag, sp) + basis_elem = arcdiag_to_deformationmap__so(T, diag, sp) if !no_normalize basis_elem = normalize(basis_elem) end diff --git a/test/DeformationBases-test.jl b/test/DeformationBases-test.jl index 07ee674..826379f 100644 --- a/test/DeformationBases-test.jl +++ b/test/DeformationBases-test.jl @@ -2,18 +2,19 @@ @testset "ArcDiagDeformBasis.jl" begin @testset "arcdiag_to_deformationmap__so(:exterior)" begin L = special_orthogonal_lie_algebra(QQ, 4) + T = Val(:special_orthogonal) V = exterior_power(standard_module(L), 2) sp = smash_product(L, V) @testset "not all specialisations are zero" begin diag = arc_diagram(Undirected, "ABBD,AD") - dm = PD.arcdiag_to_deformationmap__so(diag, sp) + dm = PD.arcdiag_to_deformationmap__so(T, diag, sp) @test !iszero(dm) end @testset "deformation is equivariant, d = $deg" for deg in 1:3 - for diag in PD.pbw_arc_diagrams__so(V, deg) - dm = PD.arcdiag_to_deformationmap__so(diag, sp) + for diag in PD.pbw_arc_diagrams__so(T, V, deg) + dm = PD.arcdiag_to_deformationmap__so(T, diag, sp) d = deform(sp, dm) @test all(iszero, pbwdeform_eqs(d, disabled=[:b, :c, :d])) end From e37f6888997a782b7190f9ed760a4bfb8bbaf6db Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Mon, 5 Feb 2024 18:04:39 +0100 Subject: [PATCH 02/13] Rename all `*__so` functions --- src/DeformationBases/ArcDiagDeformBasis.jl | 63 +++++++++---------- .../PseudographDeformBasis.jl | 2 +- test/DeformationBases-test.jl | 8 +-- 3 files changed, 36 insertions(+), 37 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index 092cce6..24b6784 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -60,12 +60,12 @@ struct ArcDiagDeformBasis{C <: RingElem} <: DeformBasis{C} tensor_product(V_nice_summand_i_l, V_nice_summand_i_r) end - diag_iter = pbw_arc_diagrams__so(T, W, d) + diag_iter = pbw_arc_diagrams(T, W, d) len = length(diag_iter) iter = ( begin @vprintln :PBWDeformations 2 "Basis generation deg $(lpad(d, maximum(ndigits, degs))), $(lpad(floor(Int, 100*(debug_counter = (debug_counter % len) + 1) / len), 3))%, $(lpad(debug_counter, ndigits(len)))/$(len)" - _basis_elem = arcdiag_to_deformationmap__so(T, diag, sp, W) + _basis_elem = arcdiag_to_deformationmap(T, diag, sp, W) basis_elem = matrix(proj_to_summand_l) * _basis_elem * transpose(matrix(proj_to_summand_r)) if i_l != i_r basis_elem -= transpose(basis_elem) @@ -110,28 +110,28 @@ end Base.length(basis::ArcDiagDeformBasis) = basis.len -function pbw_arc_diagrams__so(T::SO, V::LieAlgebraModule, d::Int) - n_upper_vertices = arc_diagram_num_points__so(T, V) +function pbw_arc_diagrams(T::SO, V::LieAlgebraModule, d::Int) + n_upper_vertices = arc_diagram_num_points(T, V) n_lower_vertices = 2d - upper_indep_sets = arc_diagram_indep_sets__so(T, V) + upper_indep_sets = arc_diagram_indep_sets(T, V) lower_indep_sets = Vector{Int}[[[2i - 1, 2i] for i in 1:div(n_lower_vertices, 2)]...] indep_sets = Vector{Int}[[(-1) .* is for is in upper_indep_sets]; [is for is in lower_indep_sets]] return all_arc_diagrams(Undirected, n_upper_vertices, n_lower_vertices; indep_sets) end -function arc_diagram_num_points__so(T::SO, V::LieAlgebraModule) +function arc_diagram_num_points(T::SO, V::LieAlgebraModule) if is_standard_module(V) return 1 elseif is_tensor_product(V) - return sum(arc_diagram_num_points__so(T, W) for W in base_modules(V)) + return sum(arc_diagram_num_points(T, W) for W in base_modules(V)) elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) - return arc_diagram_num_points__so(T, base_module(V)) * get_attribute(V, :power) + return arc_diagram_num_points(T, base_module(V)) * get_attribute(V, :power) else error("Not implemented.") end end -function arc_diagram_indep_sets__so(T::SO, V::LieAlgebraModule) +function arc_diagram_indep_sets(T::SO, V::LieAlgebraModule) if is_standard_module(V) return Vector{Int}[] elseif is_tensor_product(V) @@ -146,21 +146,21 @@ function arc_diagram_indep_sets__so(T::SO, V::LieAlgebraModule) return Vector{Int}[] end else - iss = arc_diagram_indep_sets__so(T, inner_mod) - return [map(i -> i + k * arc_diagram_num_points__so(T, inner_mod), is) for k in 0:power-1 for is in iss] + iss = arc_diagram_indep_sets(T, inner_mod) + return [map(i -> i + k * arc_diagram_num_points(T, inner_mod), is) for k in 0:power-1 for is in iss] end else error("Not implemented.") end end -function arc_diagram_label_iterator__so(T::SO, V::LieAlgebraModule, base_labels::AbstractVector{Int}) +function arc_diagram_label_iterator(T::SO, V::LieAlgebraModule, base_labels::AbstractVector{Int}) if is_standard_module(V) return [[l] for l in base_labels] elseif is_tensor_product(V) inner_mods = base_modules(V) return ProductIterator([ - arc_diagram_label_iterator__so(T, inner_mod, base_labels) for inner_mod in reverse(inner_mods) + arc_diagram_label_iterator(T, inner_mod, base_labels) for inner_mod in reverse(inner_mods) ]) .|> reverse .|> Iterators.flatten .|> @@ -168,19 +168,19 @@ function arc_diagram_label_iterator__so(T::SO, V::LieAlgebraModule, base_labels: elseif is_exterior_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - return combinations(collect(arc_diagram_label_iterator__so(T, inner_mod, base_labels)), power) .|> + return combinations(collect(arc_diagram_label_iterator(T, inner_mod, base_labels)), power) .|> Iterators.flatten .|> collect elseif is_symmetric_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - return multicombinations(collect(arc_diagram_label_iterator__so(T, inner_mod, base_labels)), power) .|> + return multicombinations(collect(arc_diagram_label_iterator(T, inner_mod, base_labels)), power) .|> Iterators.flatten .|> collect elseif is_tensor_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - return ProductIterator(arc_diagram_label_iterator__so(T, inner_mod, base_labels), power) .|> + return ProductIterator(arc_diagram_label_iterator(T, inner_mod, base_labels), power) .|> reverse .|> Iterators.flatten .|> collect @@ -210,24 +210,24 @@ function basis_index_mapping(V::LieAlgebraModule) end end -function arc_diagram_label_permutations__so(T::SO, V::LieAlgebraModule, label::AbstractVector{Int}) +function arc_diagram_label_permutations(T::SO, V::LieAlgebraModule, label::AbstractVector{Int}) if is_standard_module(V) @req length(label) == 1 "Number of labels mismatch." return [(label, 1)] elseif is_tensor_product(V) inner_mods = base_modules(V) - @req length(label) == sum(mod -> arc_diagram_num_points__so(T, mod), inner_mods) "Number of labels mismatch." + @req length(label) == sum(mod -> arc_diagram_num_points(T, mod), inner_mods) "Number of labels mismatch." return [ begin inner_label = vcat(first.(inner_iter)...) inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign) end for inner_iter in ProductIterator([ - arc_diagram_label_permutations__so( + arc_diagram_label_permutations( T, inner_mod, - label[sum(mod -> arc_diagram_num_points__so(T, mod), inner_mods[1:i-1]; init=0)+1:sum( - mod -> arc_diagram_num_points__so(T, mod), + label[sum(mod -> arc_diagram_num_points(T, mod), inner_mods[1:i-1]; init=0)+1:sum( + mod -> arc_diagram_num_points(T, mod), inner_mods[1:i]; init=0, )], @@ -237,7 +237,7 @@ function arc_diagram_label_permutations__so(T::SO, V::LieAlgebraModule, label::A elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - m = arc_diagram_num_points__so(T, inner_mod) + m = arc_diagram_num_points(T, inner_mod) @req length(label) == m * power "Number of labels mismatch." if is_exterior_power(V) return [ @@ -246,7 +246,7 @@ function arc_diagram_label_permutations__so(T::SO, V::LieAlgebraModule, label::A inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign * outer_sign) end for (outer_perm, outer_sign) in permutations_with_sign(1:power) for inner_iter in ProductIterator([ - arc_diagram_label_permutations__so(T, inner_mod, label[(outer_perm[i]-1)*m+1:outer_perm[i]*m]) for + arc_diagram_label_permutations(T, inner_mod, label[(outer_perm[i]-1)*m+1:outer_perm[i]*m]) for i in 1:power ]) ] @@ -257,7 +257,7 @@ function arc_diagram_label_permutations__so(T::SO, V::LieAlgebraModule, label::A inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign) end for outer_perm in permutations(1:power) for inner_iter in ProductIterator([ - arc_diagram_label_permutations__so(T, inner_mod, label[(outer_perm[i]-1)*m+1:outer_perm[i]*m]) for + arc_diagram_label_permutations(T, inner_mod, label[(outer_perm[i]-1)*m+1:outer_perm[i]*m]) for i in 1:power ]) ] @@ -267,9 +267,8 @@ function arc_diagram_label_permutations__so(T::SO, V::LieAlgebraModule, label::A inner_label = vcat(first.(inner_iter)...) inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign) - end for inner_iter in ProductIterator([ - arc_diagram_label_permutations__so(T, inner_mod, label[(i-1)*m+1:i*m]) for i in 1:power - ]) + end for inner_iter in + ProductIterator([arc_diagram_label_permutations(T, inner_mod, label[(i-1)*m+1:i*m]) for i in 1:power]) ] else error("Unreachable.") @@ -280,7 +279,7 @@ function arc_diagram_label_permutations__so(T::SO, V::LieAlgebraModule, label::A end -function arcdiag_to_deformationmap__so( +function arcdiag_to_deformationmap( T::SO, diag::ArcDiagramUndirected, sp::SmashProductLie{C}, @@ -304,11 +303,11 @@ function arcdiag_to_deformationmap__so( end kappa = zero_matrix(underlying_algebra(sp), nrows_kappa, ncols_kappa) - for (label_index, upper_labels) in enumerate(arc_diagram_label_iterator__so(T, W, 1:dim_stdmod_V)) + for (label_index, upper_labels) in enumerate(arc_diagram_label_iterator(T, W, 1:dim_stdmod_V)) i, j = ind_map[label_index] - entry = arcdiag_to_deformationmap_entry__so( + entry = arcdiag_to_deformationmap_entry( T, diag, W, @@ -328,7 +327,7 @@ function arcdiag_to_deformationmap__so( return kappa end -function arcdiag_to_deformationmap_entry__so( +function arcdiag_to_deformationmap_entry( T::SO, diag::ArcDiagramUndirected, W::LieAlgebraModule{C}, @@ -339,7 +338,7 @@ function arcdiag_to_deformationmap_entry__so( ) where {C <: RingElem} entry = zero(sp_alg) - for (upper_labels, sgn_upper_labels) in arc_diagram_label_permutations__so(T, W, upper_labels) + for (upper_labels, sgn_upper_labels) in arc_diagram_label_permutations(T, W, upper_labels) zeroprod = false lower_labels = [0 for _ in 1:n_lower_vertices(diag)] frees = Int[] diff --git a/src/DeformationBases/PseudographDeformBasis.jl b/src/DeformationBases/PseudographDeformBasis.jl index 0010b21..44260b9 100644 --- a/src/DeformationBases/PseudographDeformBasis.jl +++ b/src/DeformationBases/PseudographDeformBasis.jl @@ -44,7 +44,7 @@ struct PseudographDeformBasis{C <: RingElem} <: DeformBasis{C} begin @vprintln :PBWDeformations 2 "Basis generation deg $(lpad(d, maximum(ndigits, degs))), $(lpad(floor(Int, 100*(debug_counter = (debug_counter % len) + 1) / len), 3))%, $(lpad(debug_counter, ndigits(len)))/$(len)" diag = to_arcdiag(pg, part) - basis_elem = arcdiag_to_deformationmap__so(T, diag, sp) + basis_elem = arcdiag_to_deformationmap(T, diag, sp) if !no_normalize basis_elem = normalize(basis_elem) end diff --git a/test/DeformationBases-test.jl b/test/DeformationBases-test.jl index 826379f..c96ff5d 100644 --- a/test/DeformationBases-test.jl +++ b/test/DeformationBases-test.jl @@ -1,6 +1,6 @@ @testset "DeformationBases/*.jl tests" begin @testset "ArcDiagDeformBasis.jl" begin - @testset "arcdiag_to_deformationmap__so(:exterior)" begin + @testset "arcdiag_to_deformationmap(:special_orthogonal, :exterior)" begin L = special_orthogonal_lie_algebra(QQ, 4) T = Val(:special_orthogonal) V = exterior_power(standard_module(L), 2) @@ -8,13 +8,13 @@ @testset "not all specialisations are zero" begin diag = arc_diagram(Undirected, "ABBD,AD") - dm = PD.arcdiag_to_deformationmap__so(T, diag, sp) + dm = PD.arcdiag_to_deformationmap(T, diag, sp) @test !iszero(dm) end @testset "deformation is equivariant, d = $deg" for deg in 1:3 - for diag in PD.pbw_arc_diagrams__so(T, V, deg) - dm = PD.arcdiag_to_deformationmap__so(T, diag, sp) + for diag in PD.pbw_arc_diagrams(T, V, deg) + dm = PD.arcdiag_to_deformationmap(T, diag, sp) d = deform(sp, dm) @test all(iszero, pbwdeform_eqs(d, disabled=[:b, :c, :d])) end From 55ad8096f0f00ef1f378335ef97bfe03c23e016f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 6 Feb 2024 12:13:05 +0100 Subject: [PATCH 03/13] Reorder tests --- test/runtests.jl | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/test/runtests.jl b/test/runtests.jl index 326aaae..096c0ae 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,13 +1,15 @@ include("setup.jl") -include("Aqua.jl") - +# short include("ArcDiagram-test.jl") include("DeformationBases-test.jl") include("Pseudograph-test.jl") include("SmashProductLie-test.jl") include("SmashProductLieDeform-test.jl") include("SmashProductPBWDeformLie-test.jl") + +# long +include("Aqua.jl") include("ModuleSimpleStructure-test.jl") if VERSION >= v"1.7-" From 0984c1b5f5f3ff339e329209971afb19fed3a5b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 6 Feb 2024 09:54:08 +0100 Subject: [PATCH 04/13] More renamings --- src/DeformationBases/ArcDiagDeformBasis.jl | 43 +++++++++++++--------- 1 file changed, 25 insertions(+), 18 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index 24b6784..16f614d 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -111,43 +111,50 @@ Base.length(basis::ArcDiagDeformBasis) = basis.len function pbw_arc_diagrams(T::SO, V::LieAlgebraModule, d::Int) - n_upper_vertices = arc_diagram_num_points(T, V) - n_lower_vertices = 2d - upper_indep_sets = arc_diagram_indep_sets(T, V) - lower_indep_sets = Vector{Int}[[[2i - 1, 2i] for i in 1:div(n_lower_vertices, 2)]...] - indep_sets = Vector{Int}[[(-1) .* is for is in upper_indep_sets]; [is for is in lower_indep_sets]] - return all_arc_diagrams(Undirected, n_upper_vertices, n_lower_vertices; indep_sets) + n_upper_verts = arc_diagram_upper_points(T, V) + n_lower_verts = 2d + upper_iss = arc_diagram_upper_iss(T, V) + lower_iss = Vector{Int}[[[2i - 1, 2i] for i in 1:div(n_lower_verts, 2)]...] + indep_sets = Vector{Int}[[(-1) .* is for is in upper_iss]; [is for is in lower_iss]] + return all_arc_diagrams(Undirected, n_upper_verts, n_lower_verts; indep_sets) end -function arc_diagram_num_points(T::SO, V::LieAlgebraModule) +function arc_diagram_upper_points(T::SO, V::LieAlgebraModule) if is_standard_module(V) return 1 elseif is_tensor_product(V) - return sum(arc_diagram_num_points(T, W) for W in base_modules(V)) + return sum(arc_diagram_upper_points(T, W) for W in base_modules(V)) elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) - return arc_diagram_num_points(T, base_module(V)) * get_attribute(V, :power) + return arc_diagram_upper_points(T, base_module(V)) * get_attribute(V, :power) else error("Not implemented.") end end -function arc_diagram_indep_sets(T::SO, V::LieAlgebraModule) +function arc_diagram_upper_iss(T::SO, V::LieAlgebraModule) if is_standard_module(V) return Vector{Int}[] elseif is_tensor_product(V) - return Vector{Int}[] # TODO: proper implementation + inner_mods = base_modules(V) + offset = 0 + iss = Vector{Int}[] + for mod in inner_mods + append!(iss, [is .+ offset for is in arc_diagram_upper_iss(T, mod)]) + offset += arc_diagram_upper_points(T, mod) + end + return iss elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) if is_standard_module(inner_mod) if is_exterior_power(V) - return [1:power] + return [collect(1:power)] else return Vector{Int}[] end else - iss = arc_diagram_indep_sets(T, inner_mod) - return [map(i -> i + k * arc_diagram_num_points(T, inner_mod), is) for k in 0:power-1 for is in iss] + iss = arc_diagram_upper_iss(T, inner_mod) + return [is .+ k * arc_diagram_upper_points(T, inner_mod) for k in 0:power-1 for is in iss] end else error("Not implemented.") @@ -216,7 +223,7 @@ function arc_diagram_label_permutations(T::SO, V::LieAlgebraModule, label::Abstr return [(label, 1)] elseif is_tensor_product(V) inner_mods = base_modules(V) - @req length(label) == sum(mod -> arc_diagram_num_points(T, mod), inner_mods) "Number of labels mismatch." + @req length(label) == sum(mod -> arc_diagram_upper_points(T, mod), inner_mods) "Number of labels mismatch." return [ begin inner_label = vcat(first.(inner_iter)...) @@ -226,8 +233,8 @@ function arc_diagram_label_permutations(T::SO, V::LieAlgebraModule, label::Abstr arc_diagram_label_permutations( T, inner_mod, - label[sum(mod -> arc_diagram_num_points(T, mod), inner_mods[1:i-1]; init=0)+1:sum( - mod -> arc_diagram_num_points(T, mod), + label[sum(mod -> arc_diagram_upper_points(T, mod), inner_mods[1:i-1]; init=0)+1:sum( + mod -> arc_diagram_upper_points(T, mod), inner_mods[1:i]; init=0, )], @@ -237,7 +244,7 @@ function arc_diagram_label_permutations(T::SO, V::LieAlgebraModule, label::Abstr elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - m = arc_diagram_num_points(T, inner_mod) + m = arc_diagram_upper_points(T, inner_mod) @req length(label) == m * power "Number of labels mismatch." if is_exterior_power(V) return [ From d47c4b48f33a28977e369a9a88e6c6580efdff3b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 6 Feb 2024 17:25:36 +0100 Subject: [PATCH 05/13] Start splitting some methods into two for SO and GL --- src/DeformationBases/ArcDiagDeformBasis.jl | 76 ++++++++++++++++++---- 1 file changed, 65 insertions(+), 11 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index 16f614d..e3e657a 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -1,4 +1,5 @@ const SO = Val{:special_orthogonal} +const GL = Val{:general_linear} """ Concrete subtype of [`DeformBasis`](@ref). @@ -110,15 +111,30 @@ end Base.length(basis::ArcDiagDeformBasis) = basis.len -function pbw_arc_diagrams(T::SO, V::LieAlgebraModule, d::Int) - n_upper_verts = arc_diagram_upper_points(T, V) - n_lower_verts = 2d +function pbw_arc_diagrams(T::Union{SO, GL}, V::LieAlgebraModule, d::Int) + upper_verts = arc_diagram_upper_points(T, V) + lower_verts = arc_diagram_lower_points(T, V, d) upper_iss = arc_diagram_upper_iss(T, V) - lower_iss = Vector{Int}[[[2i - 1, 2i] for i in 1:div(n_lower_verts, 2)]...] + lower_iss = arc_diagram_lower_iss(T, V, d) indep_sets = Vector{Int}[[(-1) .* is for is in upper_iss]; [is for is in lower_iss]] - return all_arc_diagrams(Undirected, n_upper_verts, n_lower_verts; indep_sets) + return all_arc_diagrams(arc_diagram_type(T), upper_verts, lower_verts; indep_sets) end + +arc_diagram_type(::SO) = Undirected + +arc_diagram_type(::GL) = Directed + + +function is_basic_building_block(::SO, V::LieAlgebraModule) + return is_standard_module(V) +end + +function is_basic_building_block(::GL, V::LieAlgebraModule) + return is_standard_module(V) || (is_dual(V) && is_standard_module(base_module(V))) +end + + function arc_diagram_upper_points(T::SO, V::LieAlgebraModule) if is_standard_module(V) return 1 @@ -131,8 +147,23 @@ function arc_diagram_upper_points(T::SO, V::LieAlgebraModule) end end -function arc_diagram_upper_iss(T::SO, V::LieAlgebraModule) +function arc_diagram_upper_points(T::GL, V::LieAlgebraModule) if is_standard_module(V) + return 1 + elseif is_dual(V) && is_standard_module(base_module(V)) + return 0 + elseif is_tensor_product(V) + return reduce(vcat, arc_diagram_upper_points(T, W) for W in base_modules(V)) + elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) + return reduce(vcat, [arc_diagram_upper_points(T, base_module(V)) for _ in 1:get_attribute(V, :power)]) + else + error("Not implemented.") + end +end + + +function arc_diagram_upper_iss(T::Union{SO, GL}, V::LieAlgebraModule) + if is_basic_building_block(T, V) return Vector{Int}[] elseif is_tensor_product(V) inner_mods = base_modules(V) @@ -146,7 +177,7 @@ function arc_diagram_upper_iss(T::SO, V::LieAlgebraModule) elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - if is_standard_module(inner_mod) + if is_basic_building_block(T, inner_mod) if is_exterior_power(V) return [collect(1:power)] else @@ -161,8 +192,27 @@ function arc_diagram_upper_iss(T::SO, V::LieAlgebraModule) end end -function arc_diagram_label_iterator(T::SO, V::LieAlgebraModule, base_labels::AbstractVector{Int}) - if is_standard_module(V) + +function arc_diagram_lower_points(::SO, _::LieAlgebraModule, d::Int) + return 2d +end + +function arc_diagram_lower_points(::GL, _::LieAlgebraModule, d::Int) + return reduce(vcat, ([1, 0] for _ in 1:d)) +end + + +function arc_diagram_lower_iss(::SO, _::LieAlgebraModule, d::Int) + return Vector{Int}[[[2i - 1, 2i] for i in 1:d]...] +end + +function arc_diagram_lower_iss(::GL, _::LieAlgebraModule, _::Int) + return Vector{Int}[] +end + + +function arc_diagram_label_iterator(T::Union{SO, GL}, V::LieAlgebraModule, base_labels::AbstractVector{Int}) + if is_basic_building_block(T, V) return [[l] for l in base_labels] elseif is_tensor_product(V) inner_mods = base_modules(V) @@ -196,6 +246,7 @@ function arc_diagram_label_iterator(T::SO, V::LieAlgebraModule, base_labels::Abs end end + function basis_index_mapping(V::LieAlgebraModule) if is_tensor_product(V) inner_mods = base_modules(V) @@ -217,8 +268,9 @@ function basis_index_mapping(V::LieAlgebraModule) end end -function arc_diagram_label_permutations(T::SO, V::LieAlgebraModule, label::AbstractVector{Int}) - if is_standard_module(V) + +function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, label::AbstractVector{Int}) + if is_basic_building_block(T, V) @req length(label) == 1 "Number of labels mismatch." return [(label, 1)] elseif is_tensor_product(V) @@ -334,6 +386,7 @@ function arcdiag_to_deformationmap( return kappa end + function arcdiag_to_deformationmap_entry( T::SO, diag::ArcDiagramUndirected, @@ -422,6 +475,7 @@ function arcdiag_to_deformationmap_entry( return entry end + function ispairgood(labeled_diag::Vector{Int}, k::Int) left_k = k % 2 == 1 ? k : k - 1 return labeled_diag[left_k] != labeled_diag[left_k+1] From 50897657f0ceb2807eb3044e79fa172eb83ab82d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 6 Feb 2024 17:25:29 +0100 Subject: [PATCH 06/13] some performance improvements --- src/DeformationBases/ArcDiagDeformBasis.jl | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index e3e657a..421de1d 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -198,12 +198,12 @@ function arc_diagram_lower_points(::SO, _::LieAlgebraModule, d::Int) end function arc_diagram_lower_points(::GL, _::LieAlgebraModule, d::Int) - return reduce(vcat, ([1, 0] for _ in 1:d)) + return reduce(vcat, ([1, 0] for _ in 1:d); init=Int[]) end function arc_diagram_lower_iss(::SO, _::LieAlgebraModule, d::Int) - return Vector{Int}[[[2i - 1, 2i] for i in 1:d]...] + return collect([2i - 1, 2i] for i in 1:d) end function arc_diagram_lower_iss(::GL, _::LieAlgebraModule, _::Int) @@ -278,7 +278,7 @@ function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, l @req length(label) == sum(mod -> arc_diagram_upper_points(T, mod), inner_mods) "Number of labels mismatch." return [ begin - inner_label = vcat(first.(inner_iter)...) + inner_label = reduce(vcat, first.(inner_iter)) inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign) end for inner_iter in ProductIterator([ @@ -301,7 +301,7 @@ function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, l if is_exterior_power(V) return [ begin - inner_label = vcat(first.(inner_iter)...) + inner_label = reduce(vcat, first.(inner_iter)) inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign * outer_sign) end for (outer_perm, outer_sign) in permutations_with_sign(1:power) for inner_iter in ProductIterator([ @@ -312,7 +312,7 @@ function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, l elseif is_symmetric_power(V) return [ begin - inner_label = vcat(first.(inner_iter)...) + inner_label = reduce(vcat, first.(inner_iter)) inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign) end for outer_perm in permutations(1:power) for inner_iter in ProductIterator([ @@ -323,7 +323,7 @@ function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, l elseif is_tensor_power(V) return [ begin - inner_label = vcat(first.(inner_iter)...) + inner_label = reduce(vcat, first.(inner_iter)) inner_sign = prod(last.(inner_iter)) (inner_label, inner_sign) end for inner_iter in From 00f279a7e3a0e4bfae7e8bfcd0f7461dfe4d340b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Wed, 7 Feb 2024 10:43:36 +0100 Subject: [PATCH 07/13] `is_basic_building_block` -> `is_tensor_generator` --- src/DeformationBases/ArcDiagDeformBasis.jl | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index 421de1d..5f20087 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -126,11 +126,11 @@ arc_diagram_type(::SO) = Undirected arc_diagram_type(::GL) = Directed -function is_basic_building_block(::SO, V::LieAlgebraModule) +function is_tensor_generator(::SO, V::LieAlgebraModule) return is_standard_module(V) end -function is_basic_building_block(::GL, V::LieAlgebraModule) +function is_tensor_generator(::GL, V::LieAlgebraModule) return is_standard_module(V) || (is_dual(V) && is_standard_module(base_module(V))) end @@ -163,7 +163,7 @@ end function arc_diagram_upper_iss(T::Union{SO, GL}, V::LieAlgebraModule) - if is_basic_building_block(T, V) + if is_tensor_generator(T, V) return Vector{Int}[] elseif is_tensor_product(V) inner_mods = base_modules(V) @@ -177,7 +177,7 @@ function arc_diagram_upper_iss(T::Union{SO, GL}, V::LieAlgebraModule) elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - if is_basic_building_block(T, inner_mod) + if is_tensor_generator(T, inner_mod) if is_exterior_power(V) return [collect(1:power)] else @@ -212,7 +212,7 @@ end function arc_diagram_label_iterator(T::Union{SO, GL}, V::LieAlgebraModule, base_labels::AbstractVector{Int}) - if is_basic_building_block(T, V) + if is_tensor_generator(T, V) return [[l] for l in base_labels] elseif is_tensor_product(V) inner_mods = base_modules(V) @@ -270,7 +270,7 @@ end function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, label::AbstractVector{Int}) - if is_basic_building_block(T, V) + if is_tensor_generator(T, V) @req length(label) == 1 "Number of labels mismatch." return [(label, 1)] elseif is_tensor_product(V) From 21d0feba4140b67cb06e67b9802eec032e57665d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Wed, 7 Feb 2024 11:08:21 +0100 Subject: [PATCH 08/13] some comments --- src/DeformationBases/ArcDiagDeformBasis.jl | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index 5f20087..e92d4d7 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -194,19 +194,23 @@ end function arc_diagram_lower_points(::SO, _::LieAlgebraModule, d::Int) + # L ≅ Sᵈ ⋀² V return 2d end function arc_diagram_lower_points(::GL, _::LieAlgebraModule, d::Int) + # L ≅ Sᵈ (V ⊗ V*) return reduce(vcat, ([1, 0] for _ in 1:d); init=Int[]) end function arc_diagram_lower_iss(::SO, _::LieAlgebraModule, d::Int) + # L ≅ Sᵈ ⋀² V return collect([2i - 1, 2i] for i in 1:d) end function arc_diagram_lower_iss(::GL, _::LieAlgebraModule, _::Int) + # L ≅ Sᵈ (V ⊗ V*) return Vector{Int}[] end From 4445ae90f1cb1a0fdf9b8e2b8f11a5e8e723eccf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 13 Feb 2024 11:37:40 +0100 Subject: [PATCH 09/13] Restrict `LieC` to `FieldElem` --- src/SmashProductLie.jl | 26 +++++++++++++------------- src/SmashProductLieDeform.jl | 30 +++++++++++++++--------------- 2 files changed, 28 insertions(+), 28 deletions(-) diff --git a/src/SmashProductLie.jl b/src/SmashProductLie.jl index f08e721..bb4dd66 100644 --- a/src/SmashProductLie.jl +++ b/src/SmashProductLie.jl @@ -3,7 +3,7 @@ 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, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} <: NCRing +@attributes mutable struct SmashProductLie{C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} <: NCRing coeff_ring::Ring L::LieAlgebra{LieC} V::LieAlgebraModule{LieC} @@ -17,12 +17,12 @@ It gets created by calling [`smash_product`](@ref). V::LieAlgebraModule{LieC}, alg::FreeAssAlgebra{C}, rels::Matrix{Union{Nothing, FreeAssAlgElem{C}}}, - ) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} + ) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} new{C, LieC, LieT}(coeff_ring, L, V, alg, rels) end end -mutable struct SmashProductLieElem{C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} <: NCRingElem +mutable struct SmashProductLieElem{C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} <: NCRingElem p::SmashProductLie{C, LieC, LieT} # parent alg_elem::FreeAssAlgElem{C} simplified::Bool @@ -31,7 +31,7 @@ mutable struct SmashProductLieElem{C <: RingElem, LieC <: RingElem, LieT <: LieA p::SmashProductLie{C, LieC, LieT}, alg_elem::FreeAssAlgElem{C}; simplified::Bool=false, - ) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} + ) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} @req underlying_algebra(p) === parent(alg_elem) "Incompatible algebras." return new{C, LieC, LieT}(p, alg_elem, simplified) end @@ -45,25 +45,25 @@ end parent_type( ::Type{SmashProductLieElem{C, LieC, LieT}}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLie{C, LieC, LieT} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLie{C, LieC, LieT} elem_type( ::Type{SmashProductLie{C, LieC, LieT}}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLieElem{C, LieC, LieT} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLieElem{C, LieC, LieT} parent(e::SmashProductLieElem) = e.p coefficient_ring( Sp::SmashProductLie{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = Sp.coeff_ring::parent_type(C) +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = Sp.coeff_ring::parent_type(C) coefficient_ring(e::SmashProductLieElem) = coefficient_ring(parent(e)) base_lie_algebra( Sp::SmashProductLie{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = Sp.L::parent_type(LieT) +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = Sp.L::parent_type(LieT) -base_module(Sp::SmashProductLie{C, LieC, LieT}) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = +base_module(Sp::SmashProductLie{C, LieC, LieT}) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = Sp.V::LieAlgebraModule{LieC} underlying_algebra(Sp::SmashProductLie) = Sp.alg @@ -114,7 +114,7 @@ end function check_parent( e1::SmashProductLieElem{C, LieC, LieT}, e2::SmashProductLieElem{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} parent(e1) != parent(e2) && error("Incompatible smash products.") end @@ -124,7 +124,7 @@ end # ############################################################################### -function show(io::IO, Sp::SmashProductLie{C, LieC}) where {C <: RingElem, LieC <: RingElem} +function show(io::IO, Sp::SmashProductLie{C, LieC}) where {C <: RingElem, LieC <: FieldElem} print(io, "Smash Product") if LieC != C print(io, " over ") @@ -165,7 +165,7 @@ end function (Sp::SmashProductLie{C, LieC, LieT})( e::SmashProductLieElem{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} @req parent(e) == Sp "Incompatible smash products." return e end @@ -239,7 +239,7 @@ end function Base.:(==)( e1::SmashProductLieElem{C, LieC, LieT}, e2::SmashProductLieElem{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} return parent(e1) === parent(e2) && simplify(e1).alg_elem == simplify(e2).alg_elem end diff --git a/src/SmashProductLieDeform.jl b/src/SmashProductLieDeform.jl index b10019a..33da68c 100644 --- a/src/SmashProductLieDeform.jl +++ b/src/SmashProductLieDeform.jl @@ -3,7 +3,7 @@ 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, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} <: +@attributes mutable struct SmashProductLieDeform{C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} <: NCRing sp::SmashProductLie{C, LieC, LieT} rels::Matrix{Union{Nothing, FreeAssAlgElem{C}}} @@ -14,12 +14,12 @@ It gets created by calling [`deform`](@ref). sp::SmashProductLie{C, LieC, LieT}, rels::Matrix{Union{Nothing, FreeAssAlgElem{C}}}, kappa::DeformationMap{C}, - ) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} + ) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} new{C, LieC, LieT}(sp, rels, kappa) end end -mutable struct SmashProductLieDeformElem{C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} <: NCRingElem +mutable struct SmashProductLieDeformElem{C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} <: NCRingElem p::SmashProductLieDeform{C, LieC, LieT} # parent alg_elem::FreeAssAlgElem{C} simplified::Bool @@ -28,7 +28,7 @@ mutable struct SmashProductLieDeformElem{C <: RingElem, LieC <: RingElem, LieT < p::SmashProductLieDeform{C, LieC, LieT}, alg_elem::FreeAssAlgElem{C}; simplified::Bool=false, - ) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} + ) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} @req underlying_algebra(p) === parent(alg_elem) "Incompatible algebras." return new{C, LieC, LieT}(p, alg_elem, simplified) end @@ -42,27 +42,27 @@ end arent_type( ::Type{SmashProductLieDeformElem{C, LieC, LieT}}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLieDeform{C, LieC, LieT} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLieDeform{C, LieC, LieT} elem_type( ::Type{SmashProductLieDeform{C, LieC, LieT}}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLieDeformElem{C, LieC, LieT} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = SmashProductLieDeformElem{C, LieC, LieT} parent(e::SmashProductLieDeformElem) = e.p coefficient_ring( D::SmashProductLieDeform{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = coefficient_ring(D.sp)::parent_type(C) +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = coefficient_ring(D.sp)::parent_type(C) coefficient_ring(e::SmashProductLieDeformElem) = coefficient_ring(parent(e)) base_lie_algebra( D::SmashProductLieDeform{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = base_lie_algebra(D.sp)::parent_type(LieT) +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = base_lie_algebra(D.sp)::parent_type(LieT) base_module( D::SmashProductLieDeform{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} = base_module(D.sp)::LieAlgebraModule{LieC} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} = base_module(D.sp)::LieAlgebraModule{LieC} underlying_algebra(D::SmashProductLieDeform) = underlying_algebra(D.sp) # TODO: create new algebra for D @@ -111,7 +111,7 @@ end function check_parent( e1::SmashProductLieDeformElem{C, LieC, LieT}, e2::SmashProductLieDeformElem{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} parent(e1) != parent(e2) && error("Incompatible smash product deformations.") end @@ -159,14 +159,14 @@ end function (D::SmashProductLieDeform{C, LieC, LieT})( e::SmashProductLieDeformElem{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} @req parent(e) == D "Incompatible smash product deformations." return e end function (D::SmashProductLieDeform{C, LieC, LieT})( e::SmashProductLieElem{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} @req parent(e) == D.sp "Incompatible smash products." return D(e.alg_elem) end @@ -240,7 +240,7 @@ end function Base.:(==)( e1::SmashProductLieDeformElem{C, LieC, LieT}, e2::SmashProductLieDeformElem{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} return parent(e1) === parent(e2) && simplify(e1).alg_elem == simplify(e2).alg_elem end @@ -281,7 +281,7 @@ Returns a [`SmashProductLieDeform`](@ref) struct and a two-part basis. function deform( sp::SmashProductLie{C, LieC, LieT}, kappa::DeformationMap{C}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} dimL = dim(base_lie_algebra(sp)) dimV = dim(base_module(sp)) @@ -318,7 +318,7 @@ Constructs the symmetric deformation of the smash product `sp`. """ function symmetric_deformation( sp::SmashProductLie{C, LieC, LieT}, -) where {C <: RingElem, LieC <: RingElem, LieT <: LieAlgebraElem{LieC}} +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} kappa = zero_matrix(underlying_algebra(sp), dim(base_module(sp)), dim(base_module(sp))) d = deform(sp, kappa) return d From 4098d240691ade9109d501042ce0164d03f9f80f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 13 Feb 2024 11:50:56 +0100 Subject: [PATCH 10/13] Add some more coercions --- src/SmashProductLie.jl | 14 ++++++++++++++ src/SmashProductLieDeform.jl | 22 ++++++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/src/SmashProductLie.jl b/src/SmashProductLie.jl index bb4dd66..a0a9ebd 100644 --- a/src/SmashProductLie.jl +++ b/src/SmashProductLie.jl @@ -170,6 +170,20 @@ function (Sp::SmashProductLie{C, LieC, LieT})( return e end +function (Sp::SmashProductLie{C, LieC, LieT})( + x::LieT, +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} + @req parent(x) == base_lie_algebra(Sp) "Incompatible smash products." + return sum(c * b for (c, b) in zip(coefficients(x), gens(Sp, :L))) +end + +function (Sp::SmashProductLie{C, LieC, LieT})( + v::LieAlgebraModuleElem{LieC}, +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} + @req parent(v) == base_module(Sp) "Incompatible smash products." + return sum(c * b for (c, b) in zip(coefficients(v), gens(Sp, :V))) +end + ############################################################################### # # Arithmetic operations diff --git a/src/SmashProductLieDeform.jl b/src/SmashProductLieDeform.jl index 33da68c..50e80d6 100644 --- a/src/SmashProductLieDeform.jl +++ b/src/SmashProductLieDeform.jl @@ -171,6 +171,20 @@ function (D::SmashProductLieDeform{C, LieC, LieT})( return D(e.alg_elem) end +function (D::SmashProductLieDeform{C, LieC, LieT})( + x::LieT, +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} + @req parent(x) == base_lie_algebra(D) "Incompatible smash products." + return sum(c * b for (c, b) in zip(coefficients(x), gens(D, :L))) +end + +function (D::SmashProductLieDeform{C, LieC, LieT})( + v::LieAlgebraModuleElem{LieC}, +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} + @req parent(v) == base_module(D) "Incompatible smash products." + return sum(c * b for (c, b) in zip(coefficients(v), gens(D, :V))) +end + ############################################################################### # # Arithmetic operations @@ -311,6 +325,14 @@ function deform( return d end +function deform( + sp::SmashProductLie{C, LieC, LieT}, + kappa::MatElem{SmashProductLieElem{C, LieC, LieT}}, +) where {C <: RingElem, LieC <: FieldElem, LieT <: LieAlgebraElem{LieC}} + @req all(x -> parent(x) == sp, kappa) "Incompatible smash products." + return deform(sp, map_entries(x -> x.alg_elem, kappa)) +end + """ symmetric_deformation(sp::SmashProductLie{C}) where {C <: RingElem} From 06427c2f93ef870a8b6744335ebd6c59ce07a265 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 13 Feb 2024 11:54:19 +0100 Subject: [PATCH 11/13] Make ArcDiagDeformBasis work for GL --- src/DeformationBases/ArcDiagDeformBasis.jl | 163 ++++++++++++++++++--- 1 file changed, 146 insertions(+), 17 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index e92d4d7..717f3c9 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -19,12 +19,12 @@ struct ArcDiagDeformBasis{C <: RingElem} <: DeformBasis{C} no_normalize::Bool=false, ) where {C <: RingElem} T = get_attribute(base_lie_algebra(sp), :type, nothing) - @req T == :special_orthogonal "Only works for so_n." + @req T in [:special_orthogonal, :general_linear] "Only works for so_n and gl_n." return ArcDiagDeformBasis{C}(Val(T), sp, degs; no_normalize) end function ArcDiagDeformBasis{C}( - T::Union{SO}, + T::Union{SO, GL}, sp::SmashProductLie{C}, degs::AbstractVector{Int}; no_normalize::Bool=false, @@ -161,6 +161,14 @@ function arc_diagram_upper_points(T::GL, V::LieAlgebraModule) end end +function arc_diagram_num_upper_points(T::SO, V::LieAlgebraModule) + return arc_diagram_upper_points(T, V) +end + +function arc_diagram_num_upper_points(T::GL, V::LieAlgebraModule) + return length(arc_diagram_upper_points(T, V)) +end + function arc_diagram_upper_iss(T::Union{SO, GL}, V::LieAlgebraModule) if is_tensor_generator(T, V) @@ -171,7 +179,7 @@ function arc_diagram_upper_iss(T::Union{SO, GL}, V::LieAlgebraModule) iss = Vector{Int}[] for mod in inner_mods append!(iss, [is .+ offset for is in arc_diagram_upper_iss(T, mod)]) - offset += arc_diagram_upper_points(T, mod) + offset += arc_diagram_num_upper_points(T, mod) end return iss elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) @@ -185,7 +193,7 @@ function arc_diagram_upper_iss(T::Union{SO, GL}, V::LieAlgebraModule) end else iss = arc_diagram_upper_iss(T, inner_mod) - return [is .+ k * arc_diagram_upper_points(T, inner_mod) for k in 0:power-1 for is in iss] + return [is .+ k * arc_diagram_num_upper_points(T, inner_mod) for k in 0:power-1 for is in iss] end else error("Not implemented.") @@ -203,6 +211,14 @@ function arc_diagram_lower_points(::GL, _::LieAlgebraModule, d::Int) return reduce(vcat, ([1, 0] for _ in 1:d); init=Int[]) end +function arc_diagram_num_lower_points(T::SO, V::LieAlgebraModule, d::Int) + return arc_diagram_lower_points(T, V, d) +end + +function arc_diagram_num_lower_points(T::GL, V::LieAlgebraModule, d::Int) + return length(arc_diagram_lower_points(T, V, d)) +end + function arc_diagram_lower_iss(::SO, _::LieAlgebraModule, d::Int) # L ≅ Sᵈ ⋀² V @@ -214,6 +230,23 @@ function arc_diagram_lower_iss(::GL, _::LieAlgebraModule, _::Int) return Vector{Int}[] end +function arc_diagram_lower_pair_to_L(::SO, dim_stdmod_V::Int) + # L ≅ Sᵈ ⋀² V + iso_pair_to_L = Dict{Vector{Int}, Int}() + for (i, bs) in enumerate(combinations(dim_stdmod_V, 2)) + iso_pair_to_L[bs] = i + end + return iso_pair_to_L +end + +function arc_diagram_lower_pair_to_L(::GL, dim_stdmod_V::Int) + # L ≅ Sᵈ (V ⊗ V*) + iso_pair_to_L = Dict{Vector{Int}, Int}() + for (i, bs) in enumerate(ProductIterator(1:dim_stdmod_V, 2) .|> reverse) + iso_pair_to_L[bs] = i + end + return iso_pair_to_L +end function arc_diagram_label_iterator(T::Union{SO, GL}, V::LieAlgebraModule, base_labels::AbstractVector{Int}) if is_tensor_generator(T, V) @@ -279,7 +312,7 @@ function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, l return [(label, 1)] elseif is_tensor_product(V) inner_mods = base_modules(V) - @req length(label) == sum(mod -> arc_diagram_upper_points(T, mod), inner_mods) "Number of labels mismatch." + @req length(label) == sum(mod -> arc_diagram_num_upper_points(T, mod), inner_mods) "Number of labels mismatch." return [ begin inner_label = reduce(vcat, first.(inner_iter)) @@ -289,8 +322,8 @@ function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, l arc_diagram_label_permutations( T, inner_mod, - label[sum(mod -> arc_diagram_upper_points(T, mod), inner_mods[1:i-1]; init=0)+1:sum( - mod -> arc_diagram_upper_points(T, mod), + label[sum(mod -> arc_diagram_num_upper_points(T, mod), inner_mods[1:i-1]; init=0)+1:sum( + mod -> arc_diagram_num_upper_points(T, mod), inner_mods[1:i]; init=0, )], @@ -300,7 +333,7 @@ function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, l elseif is_exterior_power(V) || is_symmetric_power(V) || is_tensor_power(V) inner_mod = base_module(V) power = get_attribute(V, :power) - m = arc_diagram_upper_points(T, inner_mod) + m = arc_diagram_num_upper_points(T, inner_mod) @req length(label) == m * power "Number of labels mismatch." if is_exterior_power(V) return [ @@ -343,21 +376,18 @@ end function arcdiag_to_deformationmap( - T::SO, - diag::ArcDiagramUndirected, + T::Union{SO, GL}, + diag::ArcDiagram, sp::SmashProductLie{C}, W::LieAlgebraModule=exterior_power(base_module(sp), 2), ) where {C <: RingElem} @req !is_direct_sum(W) "Not permitted for direct sums." ind_map = basis_index_mapping(W) - # TODO: allow for genereal ArcDiagrams dim_stdmod_V = base_lie_algebra(sp).n - iso_wedge2V_to_L = Dict{Vector{Int}, Int}() - for (i, bs) in enumerate(combinations(dim_stdmod_V, 2)) - iso_wedge2V_to_L[bs] = i - end + iso_pair_to_L = arc_diagram_lower_pair_to_L(T, dim_stdmod_V) + if is_exterior_power(W) nrows_kappa = ncols_kappa = dim(base_module(W)) @@ -376,7 +406,7 @@ function arcdiag_to_deformationmap( W, upper_labels, underlying_algebra(sp), - iso_wedge2V_to_L, + iso_pair_to_L, dim_stdmod_V, ) @@ -451,7 +481,7 @@ function arcdiag_to_deformationmap_entry( fill(C(1 // factorial(length(basiselem))), factorial(length(basiselem))), [ind for ind in permutations(basiselem)], ) - entry_summand += sign_lower_labels * symm_basiselem # TODO: benchmark removal of normal_form + entry_summand += sign_lower_labels * symm_basiselem end # end inner @@ -484,3 +514,102 @@ function ispairgood(labeled_diag::Vector{Int}, k::Int) left_k = k % 2 == 1 ? k : k - 1 return labeled_diag[left_k] != labeled_diag[left_k+1] end + +function arcdiag_to_deformationmap_entry( + T::GL, + diag::ArcDiagramDirected, + W::LieAlgebraModule{C}, + upper_labels::AbstractVector{Int}, + sp_alg::FreeAssAlgebra{C}, + iso_pair_to_L::Dict{Vector{Int}, Int}, + max_label::Int, +) where {C <: RingElem} + return arcdiag_to_deformationmap_entry( + T, + arc_diagram(Undirected, diag), + W, + upper_labels, + sp_alg, + iso_pair_to_L, + max_label, + ) +end + +function arcdiag_to_deformationmap_entry( + T::GL, + diag::ArcDiagramUndirected, + W::LieAlgebraModule{C}, + upper_labels::AbstractVector{Int}, + sp_alg::FreeAssAlgebra{C}, + iso_pair_to_L::Dict{Vector{Int}, Int}, + max_label::Int, +) where {C <: RingElem} + entry = zero(sp_alg) + + for (upper_labels, sgn_upper_labels) in arc_diagram_label_permutations(T, W, upper_labels) + zeroprod = false + lower_labels = [0 for _ in 1:n_lower_vertices(diag)] + frees = Int[] + for v in upper_vertices(diag) + nv = neighbor(diag, v) + if is_upper_vertex(nv) && upper_labels[vertex_index(v)] != upper_labels[vertex_index(nv)] + zeroprod = true + break + elseif is_lower_vertex(nv) + lower_labels[vertex_index(nv)] = upper_labels[vertex_index(v)] + end + end + if zeroprod + continue + end + for v in lower_vertices(diag) + nv = neighbor(diag, v) + if is_lower_vertex(nv) && vertex_index(v) < vertex_index(nv) + push!(frees, vertex_index(v)) + end + end + + entry_summand = zero(sp_alg) + + # iterate over lower point labelings + nextindex = 1 + while true + if nextindex > length(frees) + # begin inner + zeroelem = false + sign_lower_labels = 1 + basiselem = Int[] + for k in 1:2:length(lower_labels) + append!(basiselem, iso_pair_to_L[[lower_labels[k], lower_labels[k+1]]]) + end + if !zeroelem + symm_basiselem = sp_alg( + fill(C(1 // factorial(length(basiselem))), factorial(length(basiselem))), + [ind for ind in permutations(basiselem)], + ) + entry_summand += sign_lower_labels * symm_basiselem + end + # end inner + + nextindex -= 1 + end + + while nextindex >= 1 && lower_labels[frees[nextindex]] == max_label + lower_labels[frees[nextindex]] = 0 + lower_labels[vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex]))] = 0 + nextindex -= 1 + end + if nextindex == 0 + break + end + lower_labels[frees[nextindex]] += 1 + lower_labels[vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex]))] += 1 + + + nextindex += 1 + end + + entry += sgn_upper_labels * entry_summand + end + return entry +end From d1c27a0ffa555eeeeef9f23c616f7938db2fefe8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 13 Feb 2024 15:20:00 +0100 Subject: [PATCH 12/13] Unify more of SO and GL cases part 1 --- src/DeformationBases/ArcDiagDeformBasis.jl | 86 ++++++++++++++-------- 1 file changed, 57 insertions(+), 29 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index 717f3c9..d4f3b35 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -232,19 +232,30 @@ end function arc_diagram_lower_pair_to_L(::SO, dim_stdmod_V::Int) # L ≅ Sᵈ ⋀² V - iso_pair_to_L = Dict{Vector{Int}, Int}() - for (i, bs) in enumerate(combinations(dim_stdmod_V, 2)) + iso_pair_to_L = Dict{Tuple{Int, Int}, Int}() + for (i, bs) in enumerate(combinations(dim_stdmod_V, 2) .|> NTuple{2}) iso_pair_to_L[bs] = i end - return iso_pair_to_L + return function (k1::Int, k2::Int) + if k1 == k2 + return 0, 0 + elseif k1 < k2 + return iso_pair_to_L[(k1, k2)], 1 + else + return iso_pair_to_L[(k2, k1)], -1 + end + end end function arc_diagram_lower_pair_to_L(::GL, dim_stdmod_V::Int) # L ≅ Sᵈ (V ⊗ V*) - iso_pair_to_L = Dict{Vector{Int}, Int}() - for (i, bs) in enumerate(ProductIterator(1:dim_stdmod_V, 2) .|> reverse) + iso_pair_to_L = Dict{Tuple{Int, Int}, Int}() + for (i, bs) in enumerate(ProductIterator(1:dim_stdmod_V, 2) .|> reverse .|> NTuple{2}) iso_pair_to_L[bs] = i end + return function (k1::Int, k2::Int) + return iso_pair_to_L[(k1, k2)], 1 + end return iso_pair_to_L end @@ -427,7 +438,7 @@ function arcdiag_to_deformationmap_entry( W::LieAlgebraModule{C}, upper_labels::AbstractVector{Int}, sp_alg::FreeAssAlgebra{C}, - iso_pair_to_L::Dict{Vector{Int}, Int}, + iso_pair_to_L::Function, max_label::Int, ) where {C <: RingElem} entry = zero(sp_alg) @@ -462,26 +473,22 @@ function arcdiag_to_deformationmap_entry( while true if nextindex > length(frees) # begin inner - zeroelem = false - sign_lower_labels = 1 + coeff_lower_labels = 1 basiselem = Int[] for k in 1:2:length(lower_labels) - if lower_labels[k] == lower_labels[k+1] - zeroelem = true + gen_ind, coeff = iso_pair_to_L(lower_labels[k], lower_labels[k+1]) + coeff_lower_labels *= coeff + if iszero(coeff_lower_labels) break - elseif lower_labels[k] > lower_labels[k+1] - sign_lower_labels *= -1 - append!(basiselem, iso_pair_to_L[[lower_labels[k+1], lower_labels[k]]]) - else - append!(basiselem, iso_pair_to_L[[lower_labels[k], lower_labels[k+1]]]) end + append!(basiselem, gen_ind) end - if !zeroelem + if !iszero(coeff_lower_labels) symm_basiselem = sp_alg( fill(C(1 // factorial(length(basiselem))), factorial(length(basiselem))), [ind for ind in permutations(basiselem)], ) - entry_summand += sign_lower_labels * symm_basiselem + entry_summand += coeff_lower_labels * symm_basiselem end # end inner @@ -498,10 +505,16 @@ function arcdiag_to_deformationmap_entry( end lower_labels[frees[nextindex]] += 1 lower_labels[vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex]))] += 1 - if ispairgood(lower_labels, frees[nextindex]) && - ispairgood(lower_labels, vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex]))) - nextindex += 1 + + if arcdiag_is_lower_pair_label_bad(T, lower_labels, frees[nextindex]) || arcdiag_is_lower_pair_label_bad( + T, + lower_labels, + vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex])), + ) + continue end + + nextindex += 1 end entry += sgn_upper_labels * entry_summand @@ -510,9 +523,13 @@ function arcdiag_to_deformationmap_entry( end -function ispairgood(labeled_diag::Vector{Int}, k::Int) +function arcdiag_is_lower_pair_label_bad(::SO, labeled_diag::Vector{Int}, k::Int) left_k = k % 2 == 1 ? k : k - 1 - return labeled_diag[left_k] != labeled_diag[left_k+1] + return labeled_diag[left_k] == labeled_diag[left_k+1] +end + +function arcdiag_is_lower_pair_label_bad(::GL, labeled_diag::Vector{Int}, k::Int) + return false end function arcdiag_to_deformationmap_entry( @@ -521,7 +538,7 @@ function arcdiag_to_deformationmap_entry( W::LieAlgebraModule{C}, upper_labels::AbstractVector{Int}, sp_alg::FreeAssAlgebra{C}, - iso_pair_to_L::Dict{Vector{Int}, Int}, + iso_pair_to_L::Function, max_label::Int, ) where {C <: RingElem} return arcdiag_to_deformationmap_entry( @@ -541,7 +558,7 @@ function arcdiag_to_deformationmap_entry( W::LieAlgebraModule{C}, upper_labels::AbstractVector{Int}, sp_alg::FreeAssAlgebra{C}, - iso_pair_to_L::Dict{Vector{Int}, Int}, + iso_pair_to_L::Function, max_label::Int, ) where {C <: RingElem} entry = zero(sp_alg) @@ -576,18 +593,22 @@ function arcdiag_to_deformationmap_entry( while true if nextindex > length(frees) # begin inner - zeroelem = false - sign_lower_labels = 1 + coeff_lower_labels = 1 basiselem = Int[] for k in 1:2:length(lower_labels) - append!(basiselem, iso_pair_to_L[[lower_labels[k], lower_labels[k+1]]]) + gen_ind, coeff = iso_pair_to_L(lower_labels[k], lower_labels[k+1]) + coeff_lower_labels *= coeff + if iszero(coeff_lower_labels) + break + end + append!(basiselem, gen_ind) end - if !zeroelem + if !iszero(coeff_lower_labels) symm_basiselem = sp_alg( fill(C(1 // factorial(length(basiselem))), factorial(length(basiselem))), [ind for ind in permutations(basiselem)], ) - entry_summand += sign_lower_labels * symm_basiselem + entry_summand += coeff_lower_labels * symm_basiselem end # end inner @@ -605,6 +626,13 @@ function arcdiag_to_deformationmap_entry( lower_labels[frees[nextindex]] += 1 lower_labels[vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex]))] += 1 + if arcdiag_is_lower_pair_label_bad(T, lower_labels, frees[nextindex]) || arcdiag_is_lower_pair_label_bad( + T, + lower_labels, + vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex])), + ) + continue + end nextindex += 1 end From dc0d5632220706e9278d5541e121069f164eb7f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= Date: Tue, 13 Feb 2024 15:21:08 +0100 Subject: [PATCH 13/13] Unify more of SO and GL cases part 2 --- src/DeformationBases/ArcDiagDeformBasis.jl | 112 ++------------------- 1 file changed, 11 insertions(+), 101 deletions(-) diff --git a/src/DeformationBases/ArcDiagDeformBasis.jl b/src/DeformationBases/ArcDiagDeformBasis.jl index d4f3b35..7d0b5c5 100644 --- a/src/DeformationBases/ArcDiagDeformBasis.jl +++ b/src/DeformationBases/ArcDiagDeformBasis.jl @@ -386,6 +386,16 @@ function arc_diagram_label_permutations(T::Union{SO, GL}, V::LieAlgebraModule, l end +function arcdiag_is_lower_pair_label_bad(::SO, labeled_diag::Vector{Int}, k::Int) + left_k = k % 2 == 1 ? k : k - 1 + return labeled_diag[left_k] == labeled_diag[left_k+1] +end + +function arcdiag_is_lower_pair_label_bad(::GL, labeled_diag::Vector{Int}, k::Int) + return false +end + + function arcdiag_to_deformationmap( T::Union{SO, GL}, diag::ArcDiagram, @@ -432,106 +442,6 @@ function arcdiag_to_deformationmap( end -function arcdiag_to_deformationmap_entry( - T::SO, - diag::ArcDiagramUndirected, - W::LieAlgebraModule{C}, - upper_labels::AbstractVector{Int}, - sp_alg::FreeAssAlgebra{C}, - iso_pair_to_L::Function, - max_label::Int, -) where {C <: RingElem} - entry = zero(sp_alg) - - for (upper_labels, sgn_upper_labels) in arc_diagram_label_permutations(T, W, upper_labels) - zeroprod = false - lower_labels = [0 for _ in 1:n_lower_vertices(diag)] - frees = Int[] - for v in upper_vertices(diag) - nv = neighbor(diag, v) - if is_upper_vertex(nv) && upper_labels[vertex_index(v)] != upper_labels[vertex_index(nv)] - zeroprod = true - break - elseif is_lower_vertex(nv) - lower_labels[vertex_index(nv)] = upper_labels[vertex_index(v)] - end - end - if zeroprod - continue - end - for v in lower_vertices(diag) - nv = neighbor(diag, v) - if is_lower_vertex(nv) && vertex_index(v) < vertex_index(nv) - push!(frees, vertex_index(v)) - end - end - - entry_summand = zero(sp_alg) - - # iterate over lower point labelings - nextindex = 1 - while true - if nextindex > length(frees) - # begin inner - coeff_lower_labels = 1 - basiselem = Int[] - for k in 1:2:length(lower_labels) - gen_ind, coeff = iso_pair_to_L(lower_labels[k], lower_labels[k+1]) - coeff_lower_labels *= coeff - if iszero(coeff_lower_labels) - break - end - append!(basiselem, gen_ind) - end - if !iszero(coeff_lower_labels) - symm_basiselem = sp_alg( - fill(C(1 // factorial(length(basiselem))), factorial(length(basiselem))), - [ind for ind in permutations(basiselem)], - ) - entry_summand += coeff_lower_labels * symm_basiselem - end - # end inner - - nextindex -= 1 - end - - while nextindex >= 1 && lower_labels[frees[nextindex]] == max_label - lower_labels[frees[nextindex]] = 0 - lower_labels[vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex]))] = 0 - nextindex -= 1 - end - if nextindex == 0 - break - end - lower_labels[frees[nextindex]] += 1 - lower_labels[vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex]))] += 1 - - if arcdiag_is_lower_pair_label_bad(T, lower_labels, frees[nextindex]) || arcdiag_is_lower_pair_label_bad( - T, - lower_labels, - vertex_index(_neighbor_of_lower_vertex(diag, frees[nextindex])), - ) - continue - end - - nextindex += 1 - end - - entry += sgn_upper_labels * entry_summand - end - return entry -end - - -function arcdiag_is_lower_pair_label_bad(::SO, labeled_diag::Vector{Int}, k::Int) - left_k = k % 2 == 1 ? k : k - 1 - return labeled_diag[left_k] == labeled_diag[left_k+1] -end - -function arcdiag_is_lower_pair_label_bad(::GL, labeled_diag::Vector{Int}, k::Int) - return false -end - function arcdiag_to_deformationmap_entry( T::GL, diag::ArcDiagramDirected, @@ -553,7 +463,7 @@ function arcdiag_to_deformationmap_entry( end function arcdiag_to_deformationmap_entry( - T::GL, + T::Union{SO, GL}, diag::ArcDiagramUndirected, W::LieAlgebraModule{C}, upper_labels::AbstractVector{Int},