Linear combinations of set partitions

experimental/SetPartitions/README.md

@@ -13,10 +13,7 @@ This includes:
 * basic set-partitions and operations on them (e.g. composition, tensor product, involution)
 * variations like colored partitions [TW18](@cite) and spatial partitions [CW16](@cite)
 * enumeration of partitions which can be constructed from a set of generators
-
-In the future, we plan to implement:
 * linear combinations of partitions
-* examples of tensor categories in the framework of [TensorCategories.jl](https://github.com/FabianMaeurer/TensorCategories.jl)
 
 ## Contact
 

experimental/SetPartitions/src/LinearSetPartition.jl

@@ -0,0 +1,241 @@
+"""
+    LinearSetPartition
+
+LinearSetPartition represents a linear combination of set-partitions. See Chapter 5 in [Gro20](@cite).
+"""
+struct LinearSetPartition{S <: AbstractPartition, T <: RingElement}
+    coefficients :: Dict{S, T}
+
+    function LinearSetPartition{S, T}(coeffs::Dict{S, T}) where {S <: AbstractPartition, T <: RingElement}
+        return new(simplify_operation_zero(coeffs))
+    end
+end 
+
+"""
+    linear_partition(coeffs::Dict{S, T}) where {S <: AbstractPartition, T <: RingElement}
+
+Initialize LinearSetPartition object, while simplifying the term.
+
+# Examples
+```jldoctest
+julia> S, d = polynomial_ring(QQ, "d") 
+(Univariate polynomial ring in x over QQ, d)
+julia> linear_partition(Dict(set_partition([1, 2], [1, 1]) => S(4), set_partition([1, 1], [1, 1]) => 4*d))
+LinearSetPartition(Dict(set_partition([1, 2], [1, 1]) => S(4), set_partition([1, 1], [1, 1]) => 4*d))
+"""
+function linear_partition(coeffs::Dict{S, T}) where {S <: AbstractPartition, T <: RingElement}
+    return LinearSetPartition{S, T}(coeffs)
+end
+
+"""
+    coefficients(p::LinearSetPartition{S, T}) where { S <: AbstractPartition, T <: RingElement }
+
+Get the constructor field `coefficients`, the partition term, in form of a `Dict` from
+`SetPartition` to coefficient.
+""" 
+function coefficients(p::LinearSetPartition{S, T}) where { S <: AbstractPartition, T <: RingElement }
+    return p.coefficients
+end
+
+function hash(p::LinearSetPartition, h::UInt)
+    return hash(coefficients(p), h) 
+end
+
+function ==(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement }
+        return coefficients(p) == coefficients(q)
+end
+
+function deepcopy_internal(p::LinearSetPartition, stackdict::IdDict)
+    if haskey(stackdict, p)
+        return stackdict[p]
+    end
+    q = linear_partition(deepcopy_internal(coefficients(p), stackdict))
+    stackdict[p] = q
+    return q
+end
+
+"""
+    linear_partition(term::Vector{Tuple{S, T}}) where { S <: AbstractPartition, T <: RingElement }
+
+Return a `LinearSetPartition` generated from the Vector `term` of 2-tuples,
+where the first element in the tuple is a `RingElement` and the second
+a `SetPartition`. Furthermore simplify the term before initializing
+the `LinearSetPartition` object with the corresponding dict.
+
+# Examples
+```jldoctest
+julia> S, d = polynomial_ring(QQ, "d")
+(Univariate polynomial ring in x over QQ, d)
+julia> linear_partition([(set_partition([1, 1], [1, 1]), S(4)), (set_partition([1, 1], [1, 1]), 4*d)])
+LinearSetPartition(Dict(set_partition([1, 1], [1, 1]) => 4 + 4*d))
+```
+"""
+function linear_partition(term::Vector{Tuple{S, T}}) where { S <: AbstractPartition, T <: RingElement }
+    return linear_partition(Dict{S, T}(x[1] => x[2] for x in simplify_operation(term)))
+end
+
+"""
+    add(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement }
+
+Return the addition between `p` and `q`.
+
+# Examples
+```jldoctest
+julia> S, d = polynomial_ring(QQ, "d")
+(Univariate polynomial ring in x over QQ, d)
+julia> a = linear_partition([(set_partition([1, 2], [1, 1]), S(4)), 
+(set_partition([1, 1], [1, 1]), 4*d)])
+julia> add(a, a)
+LinearSetPartition(Dict(set_partition([1, 2], [1, 1]) => S(8), 
+SetPartition([1, 1], [1, 1]) => 8*d))
+```
+"""
+function add(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement } 
+
+    result = deepcopy(p)
+
+    for i in pairs(coefficients(q))
+        coefficients(result)[i[1]] = get(coefficients(result), i[1], 0) + i[2]
+    end
+
+    return linear_partition(coefficients(result))
+end
+
+function +(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement }
+    return add(p, q)
+end
+
+"""
+    scale(a::RingElement, p::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement }
+
+Multiply each coefficient in `p` with `a` and return
+the result.
+
+# Examples
+```jldoctest
+julia> S, d = polynomial_ring(QQ, "d")
+(Univariate polynomial ring in x over QQ, d)
+julia> scale(S(1) / S(2), linear_partition(Dict(set_partition([1, 2], [1, 1]) => S(8), 
+set_partition([1, 1], [1, 1]) => 8*d)))
+LinearSetPartition(Dict(SetPartition([1, 2], [1, 1]) => S(4), 
+SetPartition([1, 1], [1, 1]) => 4*d))
+```
+"""
+function scale(a::RingElement, p::LinearSetPartition{S, T}) where
+        { S <: AbstractPartition, T <: RingElement }
+    result = Dict{S, T}()
+
+    for (i, n) in pairs(coefficients(p))
+        result[i] = a * n
+    end
+    return linear_partition(result)
+end 
+
+function *(a::RingElement, p::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement }
+    return scale(a, p)
+end
+
+"""
+    compose(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}, d::T) where 
+        { S <: AbstractPartition, T <: RingElement }
+
+Multiply each coefficient from `p` with each coefficient from `q`
+as well as perform a composition between each SetPartition part 
+in `p` and `q` and return the result.
+
+# Examples
+```jldoctest
+julia> S, d = polynomial_ring(QQ, "d")
+(Univariate polynomial ring in x over QQ, d)
+julia> a = linear_partition([(set_partition([1, 2], [1, 1]), S(4)), 
+(SetPartition([1, 1], [1, 1]), 4*d)])
+julia> compose(a, a, d)
+LinearSetPartition(Dict(SetPartition([1, 2], [1, 1]) => 16*d + 16, 
+SetPartition([1, 1], [1, 1]) => 16*d^2 + 16*d))
+```
+"""
+function compose(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}, d::T) where 
+        { S <: AbstractPartition, T <: RingElement }
+    result = Dict{S, T}()
+
+    for i in pairs(coefficients(p))
+        for ii in pairs(coefficients(q))
+            (composition, loop) = compose_count_loops(i[1], ii[1])
+            new_coefficient = i[2] * ii[2] * (d^loop)
+            result[composition] = get(result, composition, 0) + new_coefficient
+        end
+    end
+    return linear_partition(result)
+end 
+
+"""
+    tensor_product(p::LinearSetPartition{P, R}, q::LinearSetPartition{P, R}) where 
+        { P <: AbstractPartition, R <: RingElement }
+
+Return the tensor product of `p` and `q`.
+
+# Examples
+```jldoctest
+julia> S, d = polynomial_ring(QQ, "d")
+(Univariate polynomial ring in x over QQ, d)
+julia> a = linear_partition([(set_partition([1, 2], [1, 1]), S(4)), 
+(set_partition([1, 1], [1, 1]), 4*d)])
+julia> tensor_product(a, a)
+LinearSetPartition(Dict(SetPartition([1, 1, 2, 2], [1, 1, 2, 2]) => 16*d^2, 
+SetPartition([1, 2, 3, 3], [1, 1, 3, 3]) => 16*d, 
+SetPartition([1, 2, 3, 4], [1, 1, 3, 3]) => S(16), 
+SetPartition([1, 1, 2, 3], [1, 1, 2, 2]) => 16*d)))
+```
+"""
+function tensor_product(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement }
+
+    result = Dict{S, T}()
+
+    for i in pairs(coefficients(p))
+        for ii in pairs(coefficients(q))
+            composition = tensor_product(i[1], ii[1])
+            new_coefficient = i[2] * ii[2]
+            result[composition] = get(result, composition, 0) + new_coefficient
+        end
+    end
+
+    return linear_partition(result)
+end 
+
+function ⊗(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement }
+    return tensor_product(p, q)
+end
+
+"""
+    subtract(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement }
+
+Perform a subtraction between `p` and `q` and return the result.
+
+# Examples
+```jldoctest
+julia> S, d = polynomial_ring(QQ, "d")
+(Univariate polynomial ring in x over QQ, d)
+julia> a = linear_partition([(set_partition([1, 2], [1, 1]), S(4)), 
+(SetPartition([1, 1], [1, 1]), 4*d)])
+julia> subtract(a, a)
+LinearSetPartition(Dict(SetPartition([1, 1], [1, 1]) => S(0)))
+```
+"""
+function subtract(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}) where 
+        { S <: AbstractPartition, T <: RingElement }
+    return add(p, scale(-1, q))
+end 
+
+function -(p::LinearSetPartition{S, T}, q::LinearSetPartition{S, T}) where 
+    { S <: AbstractPartition, T <: RingElement }
+    return subtract(p, q)
+end 

experimental/SetPartitions/src/SetPartitions.jl

@@ -7,7 +7,9 @@ import Base:
     deepcopy,
     deepcopy_internal,
     hash,
-    size
+    size,
+    -,
+    +
 
 import Oscar:
     ⊗,
@@ -19,11 +21,16 @@ import Oscar:
     parent,
     degree,
     tensor_product,
-    @req
+    @req,
+    RingElement,
+    scale,
+    coefficients,
+    iszero
 
 export ColoredPartition
 export SetPartition
 export SpatialPartition
+export LinearSetPartition
 
 export colored_partition
 export compose_count_loops
@@ -51,6 +58,13 @@ export set_partition
 export spatial_partition
 export upper_colors
 export upper_points
+export simplify_operation_zero
+export simplify_operation
+export linear_partition
+export add
+export scale
+export subtract
+
 
 
 include("AbstractPartition.jl")
@@ -60,13 +74,15 @@ include("ColoredPartition.jl")
 include("SpatialPartition.jl")
 include("PartitionProperties.jl")
 include("GenerateCategory.jl")
+include("LinearSetPartition.jl")
 end
 
 using .SetPartitions
 
 export ColoredPartition
 export SetPartition
 export SpatialPartition
+export LinearSetPartition
 
 export colored_partition
 export compose_count_loops
@@ -94,3 +110,9 @@ export set_partition
 export spatial_partition
 export upper_colors
 export upper_points
+export simplify_operation_zero
+export simplify_operation
+export linear_partition
+export add
+export scale
+export subtract

experimental/SetPartitions/src/Util.jl

@@ -123,3 +123,46 @@ function _add_partition_top_bottom(vector::Vector{Dict{Int, Set{T}}}, p::T) wher
 
     return vector
 end
+
+"""
+    simplify_operation(partition_sum::Vector{Tuple{S, T}}) where { S <: AbstractPartition, T <: RingElement }
+
+Simplify the vector representation of a `LinearSetPartition` in terms of associativity.
+"""
+function simplify_operation(partition_sum::Vector{Tuple{S, T}}) where { S <: AbstractPartition, T <: RingElement }
+
+    partitions = Dict{S, T}()
+
+    for (i1, i2) in partition_sum
+
+        if iszero(i2)
+            deleteat!(partition_sum, findall(x -> x == (i1, i2), partition_sum))
+            continue
+        end
+
+        if !(i1 in keys(partitions))
+            partitions[i1] = i2
+        else
+            deleteat!(partition_sum, findall(x -> x == (i1, i2), partition_sum))
+            deleteat!(partition_sum, findall(x -> x == (i1, get(partitions, i1, -1)), partition_sum))
+            push!(partition_sum, (i1, get(partitions, i1, -1) + i2))
+            partitions[i1] = get(partitions, i1, -1) + i2
+        end
+    end
+    return partition_sum
+end
+
+"""
+    simplify_operation_zero(p::Dict{S, T}) where { S <: AbstractPartition, T <: RingElement }
+
+Simplify the dict representation of a `LinearSetPartition` in terms of zero coefficients.
+"""
+function simplify_operation_zero(p::Dict{S, T}) where { S <: AbstractPartition, T <: RingElement }
+    result = Dict{S, T}()
+    for (i1, i2) in pairs(p)
+        if !iszero(i2)
+            result[i1] = i2
+        end
+    end
+    return result
+end

experimental/SetPartitions/test/LinearComb-test.jl

@@ -0,0 +1,25 @@
+@testset "LinearCombinations of SetPartitions" begin
+    @testset "LinearSetPartition Constructor" begin
+        S, d = polynomial_ring(QQ, "d")
+        @test coefficients(linear_partition(Dict(set_partition([1, 2], [1, 1]) => S(4), set_partition([1, 1], [1, 1]) => 8*d))) == Dict(set_partition([1, 2], [1, 1]) => S(4), set_partition([1, 1], [1, 1]) => 8*d)
+        @test coefficients(linear_partition(Dict(set_partition([1, 2], [1, 1]) => S(0), set_partition([1, 1], [1, 1]) => 8*d))) == Dict(set_partition([1, 1], [1, 1]) => 8*d)
+        @test coefficients(linear_partition([(set_partition([1, 1], [1, 1]), S(5)), (set_partition([1, 1], [1, 1]), 4*d)])) == Dict(set_partition([1, 1], [1, 1]) => 5 + 4*d)
+    end
+
+    @testset "LinearPartition Operations" begin
+        S, d = polynomial_ring(QQ, "d")
+        a = linear_partition([(set_partition([1, 2], [1, 1]), S(5)), (set_partition([1, 1], [1, 1]), 5*d)])
+        @test add(a, a) == a + a == linear_partition(Dict(set_partition([1, 2], [1, 1]) => S(10), set_partition([1, 1], [1, 1]) => 10*d))
+        @test add(a, linear_partition([(set_partition([1, 1], [1, 1]), S(1)), (set_partition([1, 1], [1, 1]), 2*d)])) == linear_partition([(set_partition([1, 2], [1, 1]), S(5)), (set_partition([1, 1], [1, 1]), 7*d + 1)])
+
+        @test scale(S(2), linear_partition(Dict(set_partition([1, 2], [1, 1]) => S(10), set_partition([1, 1], [1, 1]) => 8*d))) == S(2) * linear_partition(Dict(set_partition([1, 2], [1, 1]) => S(10), set_partition([1, 1], [1, 1]) => 8*d)) == linear_partition(Dict(set_partition([1, 2], [1, 1]) => S(20), set_partition([1, 1], [1, 1]) => 16*d))
+        @test scale(S(1) / S(2), linear_partition(Dict(set_partition([1, 2], [1, 1]) => S(8), set_partition([1, 1], [1, 1]) => 8*d))) == linear_partition(Dict(SetPartition([1, 2], [1, 1]) => S(4), SetPartition([1, 1], [1, 1]) => 4*d))
+
+        a = linear_partition([(set_partition([1, 2], [1, 1]), S(4)), (set_partition([1, 1], [1, 1]), 4*d)])
+        @test compose(a, a, d) == linear_partition(Dict(set_partition([1, 2], [1, 1]) => 16*d + 16, set_partition([1, 1], [1, 1]) => 16*d^2 + 16*d))
+
+        @test tensor_product(a, a) == linear_partition(Dict(set_partition([1, 1, 2, 2], [1, 1, 2, 2]) => 16*d^2, set_partition([1, 2, 3, 3], [1, 1, 3, 3]) => 16*d, set_partition([1, 2, 3, 4], [1, 1, 3, 3]) => S(16), set_partition([1, 1, 2, 3], [1, 1, 2, 2]) => 16*d))
+
+        @test subtract(a, a) == a - a == linear_partition(Dict(set_partition([1, 1], [1, 1]) => S(0)))
+    end
+end