Partition/Diagram Algebras

class sage.combinat.partition_algebra.PartitionAlgebraElement_ak(A, x)
class sage.combinat.partition_algebra.PartitionAlgebraElement_bk(A, x)
class sage.combinat.partition_algebra.PartitionAlgebraElement_generic(A, x)
class sage.combinat.partition_algebra.PartitionAlgebraElement_pk(A, x)
class sage.combinat.partition_algebra.PartitionAlgebraElement_prk(A, x)
class sage.combinat.partition_algebra.PartitionAlgebraElement_rk(A, x)
class sage.combinat.partition_algebra.PartitionAlgebraElement_sk(A, x)
class sage.combinat.partition_algebra.PartitionAlgebraElement_tk(A, x)
class sage.combinat.partition_algebra.PartitionAlgebra_ak(R, k, n, name=None)
__init__(R, k, n, name=None)

EXAMPLES:

sage: from sage.combinat.partition_algebra import *
sage: p = PartitionAlgebra_ak(QQ, 3, 1)
sage: p == loads(dumps(p))
True
class sage.combinat.partition_algebra.PartitionAlgebra_bk(R, k, n, name=None)
__init__(R, k, n, name=None)

EXAMPLES:

sage: from sage.combinat.partition_algebra import *
sage: p = PartitionAlgebra_bk(QQ, 3, 1)
sage: p == loads(dumps(p))
True
class sage.combinat.partition_algebra.PartitionAlgebra_generic(R, cclass, n, k, name=None, prefix=None)
__init__(R, cclass, n, k, name=None, prefix=None)

EXAMPLES:

sage: from sage.combinat.partition_algebra import *
sage: s = PartitionAlgebra_sk(QQ, 3, 1)
sage: s == loads(dumps(s))
True
_multiply_basis(left, right)

EXAMPLES:

sage: from sage.combinat.partition_algebra import *
sage: s = PartitionAlgebra_sk(QQ, 3, 1)
sage: t12 = s(Set([Set([1,-2]),Set([2,-1]),Set([3,-3])]))
sage: t12^2 == s(1) #indirect doctest
True
class sage.combinat.partition_algebra.PartitionAlgebra_pk(R, k, n, name=None)
__init__(R, k, n, name=None)

EXAMPLES:

sage: from sage.combinat.partition_algebra import *
sage: p = PartitionAlgebra_pk(QQ, 3, 1)
sage: p == loads(dumps(p))
True
class sage.combinat.partition_algebra.PartitionAlgebra_prk(R, k, n, name=None)
__init__(R, k, n, name=None)

EXAMPLES:

sage: from sage.combinat.partition_algebra import *
sage: p = PartitionAlgebra_prk(QQ, 3, 1)
sage: p == loads(dumps(p))
True
class sage.combinat.partition_algebra.PartitionAlgebra_rk(R, k, n, name=None)
__init__(R, k, n, name=None)

EXAMPLES:

sage: from sage.combinat.partition_algebra import *
sage: p = PartitionAlgebra_rk(QQ, 3, 1)
sage: p == loads(dumps(p))
True
class sage.combinat.partition_algebra.PartitionAlgebra_sk(R, k, n, name=None)
__init__(R, k, n, name=None)

EXAMPLES:

sage: from sage.combinat.partition_algebra import *
sage: p = PartitionAlgebra_sk(QQ, 3, 1)
sage: p == loads(dumps(p))
True
class sage.combinat.partition_algebra.PartitionAlgebra_tk(R, k, n, name=None)
__init__(R, k, n, name=None)

EXAMPLES:

sage: from sage.combinat.partition_algebra import *
sage: p = PartitionAlgebra_tk(QQ, 3, 1)
sage: p == loads(dumps(p))
True
class sage.combinat.partition_algebra.SetPartitionsAk_k(k)
__init__(k)

TESTS:

sage: A3 = SetPartitionsAk(3); A3
Set partitions of {1, ..., 3, -1, ..., -3}
sage: A3 == loads(dumps(A3))
True
__repr__()

TESTS:

sage: repr(SetPartitionsAk(3))
'Set partitions of {1, ..., 3, -1, ..., -3}'
class sage.combinat.partition_algebra.SetPartitionsAkhalf_k(k)
__contains__(x)

TESTS:

sage: A2p5 = SetPartitionsAk(2.5)
sage: all([ sp in A2p5 for sp in A2p5])
True
sage: A3 = SetPartitionsAk(3)
sage: len(filter(lambda x: x in A2p5, A3))
52
sage: A2p5.cardinality()
52
__init__(k)

TESTS:

sage: A2p5 = SetPartitionsAk(2.5); A2p5
Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block
sage: A2p5 == loads(dumps(A2p5))
True
__iter__()

TESTS:

sage: SetPartitionsAk(1.5).list() #random
[{{1, 2, -2, -1}},
 {{2, -2, -1}, {1}},
 {{2, -2}, {1, -1}},
 {{-1}, {1, 2, -2}},
 {{-1}, {2, -2}, {1}}]
sage: ks = [ 1.5, 2.5, 3.5 ]
sage: aks = map(SetPartitionsAk, ks)
sage: all([ak.cardinality() == len(ak.list()) for ak in aks])
True
__repr__()

TESTS:

sage: repr(SetPartitionsAk(2.5))
'Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block'
cardinality()

TESTS:

sage: SetPartitionsAk(1.5).cardinality()
5
sage: SetPartitionsAk(2.5).cardinality()
52
sage: SetPartitionsAk(3.5).cardinality()
877
class sage.combinat.partition_algebra.SetPartitionsBk_k(k)
__contains__(x)

TESTS:

sage: B3 = SetPartitionsBk(3)
sage: A3 = SetPartitionsAk(3)
sage: len(filter(lambda x: x in B3, A3))
15
sage: B3.cardinality()
15
__iter__()

TESTS:

sage: SetPartitionsBk(1).list()
[{{1, -1}}]
sage: SetPartitionsBk(2).list() #random
[{{2, -1}, {1, -2}}, {{2, -2}, {1, -1}}, {{1, 2}, {-1, -2}}]
sage: SetPartitionsBk(3).list() #random
[{{2, -2}, {1, -3}, {3, -1}},
 {{2, -1}, {1, -3}, {3, -2}},
 {{1, -3}, {2, 3}, {-1, -2}},
 {{3, -1}, {1, -2}, {2, -3}},
 {{3, -2}, {1, -1}, {2, -3}},
 {{1, 3}, {2, -3}, {-1, -2}},
 {{2, -1}, {3, -3}, {1, -2}},
 {{2, -2}, {3, -3}, {1, -1}},
 {{1, 2}, {3, -3}, {-1, -2}},
 {{-3, -2}, {2, 3}, {1, -1}},
 {{1, 3}, {-3, -2}, {2, -1}},
 {{1, 2}, {3, -1}, {-3, -2}},
 {{-3, -1}, {2, 3}, {1, -2}},
 {{1, 3}, {-3, -1}, {2, -2}},
 {{1, 2}, {3, -2}, {-3, -1}}]

Check to make sure that the number of elements generated is the same as what is given by cardinality()

sage: bks = [ SetPartitionsBk(i) for i in range(1, 6) ]
sage: all( [ bk.cardinality() == len(bk.list()) for bk in bks] )
True
__repr__()

TESTS:

sage: repr(SetPartitionsBk(2.5))
'Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block and with block size 2'
cardinality()

Returns the number of set partitions in B_k where k is an integer. This is given by (2k)!! = (2k-1)*(2k-3)*...*5*3*1.

EXAMPLES:

sage: SetPartitionsBk(3).cardinality()
15
sage: SetPartitionsBk(2).cardinality()
3
sage: SetPartitionsBk(1).cardinality()
1
sage: SetPartitionsBk(4).cardinality()
105
sage: SetPartitionsBk(5).cardinality()
945
class sage.combinat.partition_algebra.SetPartitionsBkhalf_k(k)
__contains__(x)

TESTS:

sage: A3 = SetPartitionsAk(3)
sage: B2p5 = SetPartitionsBk(2.5)
sage: all([ sp in B2p5 for sp in B2p5 ])
True
sage: len(filter(lambda x: x in B2p5, A3))
3
sage: B2p5.cardinality()
3
__iter__()

TESTS:

sage: B3p5 = SetPartitionsBk(3.5)
sage: B3p5.cardinality()
15
sage: B3p5.list() #random
[{{2, -2}, {1, -3}, {4, -4}, {3, -1}},
 {{2, -1}, {1, -3}, {4, -4}, {3, -2}},
 {{1, -3}, {2, 3}, {4, -4}, {-1, -2}},
 {{2, -3}, {1, -2}, {4, -4}, {3, -1}},
 {{2, -3}, {1, -1}, {4, -4}, {3, -2}},
 {{1, 3}, {4, -4}, {2, -3}, {-1, -2}},
 {{2, -1}, {3, -3}, {1, -2}, {4, -4}},
 {{2, -2}, {3, -3}, {1, -1}, {4, -4}},
 {{1, 2}, {3, -3}, {4, -4}, {-1, -2}},
 {{-3, -2}, {2, 3}, {1, -1}, {4, -4}},
 {{1, 3}, {-3, -2}, {2, -1}, {4, -4}},
 {{1, 2}, {-3, -2}, {4, -4}, {3, -1}},
 {{-3, -1}, {2, 3}, {1, -2}, {4, -4}},
 {{1, 3}, {-3, -1}, {2, -2}, {4, -4}},
 {{1, 2}, {-3, -1}, {4, -4}, {3, -2}}]
__repr__()

TESTS:

sage: repr(SetPartitionsBk(2.5))
'Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block and with block size 2'
cardinality()

TESTS:

sage: B3p5 = SetPartitionsBk(3.5)
sage: B3p5.cardinality()
15
class sage.combinat.partition_algebra.SetPartitionsIk_k(k)
__contains__(x)

TESTS:

sage: I3 = SetPartitionsIk(3)
sage: A3 = SetPartitionsAk(3)
sage: all([ sp in I3 for sp in I3])
True
sage: len(filter(lambda x: x in I3, A3))
197
sage: I3.cardinality()
197
__iter__()

TESTS:

sage: SetPartitionsIk(2).list() #random indirect test
    [{{1, 2, -1, -2}},
     {{2, -1, -2}, {1}},
     {{2}, {1, -1, -2}},
     {{-1}, {1, 2, -2}},
     {{-2}, {1, 2, -1}},
     {{1, 2}, {-1, -2}},
     {{2}, {-1, -2}, {1}},
     {{-1}, {2, -2}, {1}},
     {{-2}, {2, -1}, {1}},
     {{-1}, {2}, {1, -2}},
     {{-2}, {2}, {1, -1}},
     {{-1}, {-2}, {1, 2}},
     {{-1}, {-2}, {2}, {1}}]
__repr__()

TESTS:

sage: repr(SetPartitionsIk(3))
'Set partitions of {1, ..., 3, -1, ..., -3} with propagating number < 3'
cardinality()

TESTS:

sage: SetPartitionsIk(2).cardinality()
13
class sage.combinat.partition_algebra.SetPartitionsIkhalf_k(k)
__contains__(x)

TESTS:

sage: I2p5 = SetPartitionsIk(2.5)
sage: A3 = SetPartitionsAk(3)
sage: all([ sp in I2p5 for sp in I2p5])
True
sage: len(filter(lambda x: x in I2p5, A3))
50
sage: I2p5.cardinality()
50
__iter__()

TESTS:

sage: SetPartitionsIk(1.5).list() #random
[{{1, 2, -2, -1}},
 {{2, -2, -1}, {1}},
 {{-1}, {1, 2, -2}},
 {{-1}, {2, -2}, {1}}]
__repr__()

TESTS:

sage: repr(SetPartitionsIk(2.5))
'Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block and propagating number < 3'
cardinality()

TESTS:

sage: SetPartitionsIk(1.5).cardinality()
4
sage: SetPartitionsIk(2.5).cardinality()
50
sage: SetPartitionsIk(3.5).cardinality()
871
class sage.combinat.partition_algebra.SetPartitionsPRk_k(k)
__contains__(x)

TESTS:

sage: PR3 = SetPartitionsPRk(3)
sage: A3 = SetPartitionsAk(3)
sage: all([ sp in PR3 for sp in PR3])
True
sage: len(filter(lambda x: x in PR3, A3))
20
sage: PR3.cardinality()
20
__init__(k)

TESTS:

sage: PR3 = SetPartitionsPRk(3); PR3
Set partitions of {1, ..., 3, -1, ..., -3} with at most 1 positive and negative entry in each block and that are planar
sage: PR3 == loads(dumps(PR3))
True
__iter__()

TESTS:

sage: len(SetPartitionsPRk(3).list() ) == SetPartitionsPRk(3).cardinality()
True
__repr__()

TESTS:

sage: repr(SetPartitionsPRk(3))
'Set partitions of {1, ..., 3, -1, ..., -3} with at most 1 positive and negative entry in each block and that are planar'
cardinality()

TESTS:

sage: SetPartitionsPRk(2).cardinality()
6
sage: SetPartitionsPRk(3).cardinality()
20
sage: SetPartitionsPRk(4).cardinality()
70
sage: SetPartitionsPRk(5).cardinality()
252
class sage.combinat.partition_algebra.SetPartitionsPRkhalf_k(k)
__contains__(x)

TESTS:

sage: A3 = SetPartitionsAk(3)
sage: PR2p5 = SetPartitionsPRk(2.5)
sage: all([ sp in PR2p5 for sp in PR2p5 ])
True
sage: len(filter(lambda x: x in PR2p5, A3))
6
sage: PR2p5.cardinality()
6
__iter__()

TESTS:

sage: list(SetPartitionsPRk(2.5))
[{{-2}, {-1}, {3, -3}, {2}, {1}},
 {{-2}, {3, -3}, {2}, {1, -1}},
 {{-1}, {3, -3}, {2}, {1, -2}},
 {{-2}, {2, -1}, {3, -3}, {1}},
 {{-1}, {2, -2}, {3, -3}, {1}},
 {{2, -2}, {3, -3}, {1, -1}}]
sage: len(_)
6
__repr__()

TESTS:

sage: repr(SetPartitionsPRk(2.5))
'Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block and with at most 1 positive and negative entry in each block and that are planar'
cardinality()

TESTS:

sage: SetPartitionsPRk(2.5).cardinality()
6
sage: SetPartitionsPRk(3.5).cardinality()
20
sage: SetPartitionsPRk(4.5).cardinality()
70
class sage.combinat.partition_algebra.SetPartitionsPk_k(k)
__contains__(x)

TESTS:

sage: P3 = SetPartitionsPk(3)
sage: A3 = SetPartitionsAk(3)
sage: len(filter(lambda x: x in P3, A3))
132
sage: P3.cardinality()
132
sage: all([sp in P3 for sp in P3])
True
__iter__()

TESTS:

sage: SetPartitionsPk(2).list() #random indirect test
[{{1, 2, -1, -2}},
 {{2, -1, -2}, {1}},
 {{2}, {1, -1, -2}},
 {{-1}, {1, 2, -2}},
 {{-2}, {1, 2, -1}},
 {{2, -2}, {1, -1}},
 {{1, 2}, {-1, -2}},
 {{2}, {-1, -2}, {1}},
 {{-1}, {2, -2}, {1}},
 {{-2}, {2, -1}, {1}},
 {{-1}, {2}, {1, -2}},
 {{-2}, {2}, {1, -1}},
 {{-1}, {-2}, {1, 2}},
 {{-1}, {-2}, {2}, {1}}]
__repr__()

TESTS:

sage: repr(SetPartitionsPk(3))
'Set partitions of {1, ..., 3, -1, ..., -3} that are planar'
cardinality()

TESTS:

sage: SetPartitionsPk(2).cardinality()
14
sage: SetPartitionsPk(3).cardinality()
132
sage: SetPartitionsPk(4).cardinality()
1430
class sage.combinat.partition_algebra.SetPartitionsPkhalf_k(k)
__contains__(x)

TESTS:

sage: A3 = SetPartitionsAk(3)
sage: P2p5 = SetPartitionsPk(2.5)
sage: all([ sp in P2p5 for sp in P2p5 ])
True
sage: len(filter(lambda x: x in P2p5, A3))
42
sage: P2p5.cardinality()
42
__iter__()

TESTS:

sage: SetPartitionsPk(1.5).list() #random
[{{1, 2, -2, -1}},
 {{2, -2, -1}, {1}},
 {{2, -2}, {1, -1}},
 {{-1}, {1, 2, -2}},
 {{-1}, {2, -2}, {1}}]
__repr__()

TESTS:

sage: repr( SetPartitionsPk(2.5) )
'Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block and that are planar'
cardinality()

TESTS:

sage: SetPartitionsPk(2.5).cardinality()
42
sage: SetPartitionsPk(1.5).cardinality()
5
class sage.combinat.partition_algebra.SetPartitionsRk_k(k)
__contains__(x)

TESTS:

sage: R3 = SetPartitionsRk(3)
sage: A3 = SetPartitionsAk(3)
sage: all([ sp in R3 for sp in R3])
True
sage: len(filter(lambda x: x in R3, A3))
34
sage: R3.cardinality()
34
__init__(k)

TESTS:

sage: R3 = SetPartitionsRk(3); R3
Set partitions of {1, ..., 3, -1, ..., -3} with at most 1 positive and negative entry in each block
sage: R3 == loads(dumps(R3))
True
__iter__()

TESTS:

sage: len(SetPartitionsRk(3).list() ) == SetPartitionsRk(3).cardinality()
True
__repr__()

TESTS:

sage: repr(SetPartitionsRk(3))
'Set partitions of {1, ..., 3, -1, ..., -3} with at most 1 positive and negative entry in each block'
cardinality()

TESTS:

sage: SetPartitionsRk(2).cardinality()
7
sage: SetPartitionsRk(3).cardinality()
34
sage: SetPartitionsRk(4).cardinality()
209
sage: SetPartitionsRk(5).cardinality()
1546
class sage.combinat.partition_algebra.SetPartitionsRkhalf_k(k)
__contains__(x)

TESTS:

sage: A3 = SetPartitionsAk(3)
sage: R2p5 = SetPartitionsRk(2.5)
sage: all([ sp in R2p5 for sp in R2p5 ])
True
sage: len(filter(lambda x: x in R2p5, A3))
7
sage: R2p5.cardinality()
7
__iter__()

TESTS:

sage: R2p5 = SetPartitionsRk(2.5)
sage: list(R2p5) #random due to sets
[{{-2}, {-1}, {3, -3}, {2}, {1}},
 {{-2}, {3, -3}, {2}, {1, -1}},
 {{-1}, {3, -3}, {2}, {1, -2}},
 {{-2}, {2, -1}, {3, -3}, {1}},
 {{-1}, {2, -2}, {3, -3}, {1}},
 {{2, -2}, {3, -3}, {1, -1}},
 {{2, -1}, {3, -3}, {1, -2}}]
sage: len(_)
7
__repr__()

TESTS:

sage: repr(SetPartitionsRk(2.5))
'Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block and with at most 1 positive and negative entry in each block'
cardinality()

TESTS:

sage: SetPartitionsRk(2.5).cardinality()
7
sage: SetPartitionsRk(3.5).cardinality()
34
sage: SetPartitionsRk(4.5).cardinality()
209
class sage.combinat.partition_algebra.SetPartitionsSk_k(k)
__contains__(x)

TESTS:

sage: A3 = SetPartitionsAk(3)
sage: S3 = SetPartitionsSk(3)
sage: all([ sp in S3 for sp in S3])
True
sage: S3.cardinality()
6
sage: len(filter(lambda x: x in S3, A3))
6
__iter__()

TESTS:

sage: SetPartitionsSk(3).list() #random
[{{2, -2}, {3, -3}, {1, -1}},
 {{1, -1}, {2, -3}, {3, -2}},
 {{2, -1}, {3, -3}, {1, -2}},
 {{1, -2}, {2, -3}, {3, -1}},
 {{1, -3}, {2, -1}, {3, -2}},
 {{1, -3}, {2, -2}, {3, -1}}]
sage: ks = range(1, 6)
sage: sks = map(SetPartitionsSk, ks)
sage: all([ sk.cardinality() == len(sk.list()) for sk in sks])
True
__repr__()

TESTS:

sage: repr(SetPartitionsSk(3))
'Set partitions of {1, ..., 3, -1, ..., -3} with propagating number 3'
cardinality()

Returns k!.

TESTS:

sage: SetPartitionsSk(2).cardinality()
2
sage: SetPartitionsSk(3).cardinality()
6
sage: SetPartitionsSk(4).cardinality()
24
sage: SetPartitionsSk(5).cardinality()
120
class sage.combinat.partition_algebra.SetPartitionsSkhalf_k(k)
__contains__(x)

TESTS:

sage: S2p5 = SetPartitionsSk(2.5)
sage: A3 = SetPartitionsAk(3)
sage: all([sp in S2p5 for sp in S2p5])
True
sage: len(filter(lambda x: x in S2p5, A3))
2
sage: S2p5.cardinality()
2
__iter__()

TESTS:

sage: SetPartitionsSk(3.5).list() #random indirect test
[{{2, -2}, {3, -3}, {1, -1}, {4, -4}},
 {{2, -3}, {1, -1}, {4, -4}, {3, -2}},
 {{2, -1}, {3, -3}, {1, -2}, {4, -4}},
 {{2, -3}, {1, -2}, {4, -4}, {3, -1}},
 {{1, -3}, {2, -1}, {4, -4}, {3, -2}},
 {{1, -3}, {2, -2}, {4, -4}, {3, -1}}]
__repr__()

TESTS:

sage: repr(SetPartitionsSk(2.5))
'Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block and propagating number 3'
cardinality()

TESTS:

sage: SetPartitionsSk(2.5).cardinality()
2
sage: SetPartitionsSk(3.5).cardinality()
6
sage: SetPartitionsSk(4.5).cardinality()
24
sage: ks = [2.5, 3.5, 4.5, 5.5]
sage: sks = [SetPartitionsSk(k) for k in ks]
sage: all([ sk.cardinality() == len(sk.list()) for sk in sks])
True
class sage.combinat.partition_algebra.SetPartitionsTk_k(k)
__contains__(x)

TESTS:

sage: T3 = SetPartitionsTk(3)
sage: A3 = SetPartitionsAk(3)
sage: all([ sp in T3 for sp in T3])
True
sage: len(filter(lambda x: x in T3, A3))
5
sage: T3.cardinality()
5
__iter__()

TESTS:

sage: SetPartitionsTk(3).list() #random
[{{1, -3}, {2, 3}, {-1, -2}},
 {{2, -2}, {3, -3}, {1, -1}},
 {{1, 2}, {3, -3}, {-1, -2}},
 {{-3, -2}, {2, 3}, {1, -1}},
 {{1, 2}, {3, -1}, {-3, -2}}]
__repr__()

TESTS:

sage: repr(SetPartitionsTk(3))
'Set partitions of {1, ..., 3, -1, ..., -3} with block size 2 and that are planar'
cardinality()

TESTS:

sage: SetPartitionsTk(2).cardinality()
2
sage: SetPartitionsTk(3).cardinality()
5
sage: SetPartitionsTk(4).cardinality()
14
sage: SetPartitionsTk(5).cardinality()
42
class sage.combinat.partition_algebra.SetPartitionsTkhalf_k(k)
__contains__(x)

TESTS:

sage: A3 = SetPartitionsAk(3)
sage: T2p5 = SetPartitionsTk(2.5)
sage: all([ sp in T2p5 for sp in T2p5 ])
True
sage: len(filter(lambda x: x in T2p5, A3))
2
sage: T2p5.cardinality()
2
__iter__()

TESTS:

sage: SetPartitionsTk(3.5).list() #random
[{{1, -3}, {2, 3}, {4, -4}, {-1, -2}},
 {{2, -2}, {3, -3}, {1, -1}, {4, -4}},
 {{1, 2}, {3, -3}, {4, -4}, {-1, -2}},
 {{-3, -2}, {2, 3}, {1, -1}, {4, -4}},
 {{1, 2}, {-3, -2}, {4, -4}, {3, -1}}]
__repr__()

TESTS:

sage: repr(SetPartitionsTk(2.5))
'Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block and with block size 2 and that are planar'
cardinality()

TESTS:

sage: SetPartitionsTk(2.5).cardinality()
2
sage: SetPartitionsTk(3.5).cardinality()
5
sage: SetPartitionsTk(4.5).cardinality()
14
sage.combinat.partition_algebra.create_set_partition_function(letter, k)

EXAMPLES:

sage: from sage.combinat.partition_algebra import create_set_partition_function
sage: create_set_partition_function('A', 3)
Set partitions of {1, ..., 3, -1, ..., -3}
sage.combinat.partition_algebra.identity(k)

Returns the identity set partition 1, -1, ..., k, -k

EXAMPLES:

sage: import sage.combinat.partition_algebra as pa
sage: pa.identity(2)
{{2, -2}, {1, -1}}
sage.combinat.partition_algebra.is_planar(sp)

Returns True if the diagram corresponding to the set partition is planar; otherwise, it returns False.

EXAMPLES:

sage: import sage.combinat.partition_algebra as pa
sage: pa.is_planar( pa.to_set_partition([[1,-2],[2,-1]]))
False
sage: pa.is_planar( pa.to_set_partition([[1,-1],[2,-2]]))
True
sage.combinat.partition_algebra.pair_to_graph(sp1, sp2)

Returns a graph consisting of the graphs of set partitions sp1 and sp2 along with edges joining the bottom row (negative numbers) of sp1 to the top row (positive numbers) of sp2.

EXAMPLES:

sage: import sage.combinat.partition_algebra as pa
sage: sp1 = pa.to_set_partition([[1,-2],[2,-1]])
sage: sp2 = pa.to_set_partition([[1,-2],[2,-1]])        
sage: g = pa.pair_to_graph( sp1, sp2 ); g
Graph on 8 vertices
sage: g.vertices() #random
[(1, 2), (-1, 1), (-2, 2), (-1, 2), (-2, 1), (2, 1), (2, 2), (1, 1)]
sage: g.edges() #random
[((1, 2), (-1, 1), None),
 ((1, 2), (-2, 2), None),
 ((-1, 1), (2, 1), None),
 ((-1, 2), (2, 2), None),
 ((-2, 1), (1, 1), None),
 ((-2, 1), (2, 2), None)]
sage.combinat.partition_algebra.propagating_number(sp)

Returns the propagating number of the set partition sp. The propagating number is the number of blocks with both a positive and negative number.

EXAMPLES:

sage: import sage.combinat.partition_algebra as pa
sage: sp1 = pa.to_set_partition([[1,-2],[2,-1]])
sage: sp2 = pa.to_set_partition([[1,2],[-2,-1]])        
sage: pa.propagating_number(sp1)
2
sage: pa.propagating_number(sp2)
0
sage.combinat.partition_algebra.set_partition_composition(sp1, sp2)

Returns a tuple consisting of the composition of the set partitions sp1 and sp2 and the number of components removed from the middle rows of the graph.

EXAMPLES:

sage: import sage.combinat.partition_algebra as pa
sage: sp1 = pa.to_set_partition([[1,-2],[2,-1]])
sage: sp2 = pa.to_set_partition([[1,-2],[2,-1]])
sage: pa.set_partition_composition(sp1, sp2) == (pa.identity(2), 0)
True
sage.combinat.partition_algebra.to_graph(sp)

Returns a graph representing the set partition sp.

EXAMPLES:

sage: import sage.combinat.partition_algebra as pa
sage: g = pa.to_graph( pa.to_set_partition([[1,-2],[2,-1]])); g
Graph on 4 vertices
sage: g.vertices() #random
[1, 2, -2, -1]
sage: g.edges() #random
[(1, -2, None), (2, -1, None)]
sage.combinat.partition_algebra.to_set_partition(l, k=None)

Coverts a list of a list of numbers to a set partitions. Each list of numbers in the outer list specifies the numbers contained in one of the blocks in the set partition.

If k is specified, then the set partition will be a set partition of 1, ..., k, -1, ..., -k. Otherwise, k will default to the minimum number needed to contain all of the specified numbers.

EXAMPLES:

sage: import sage.combinat.partition_algebra as pa
sage: pa.to_set_partition([[1,-1],[2,-2]]) == pa.identity(2)
True

Previous topic

Schubert Polynomials

Next topic

Tableaux and Tableaux-like Objects

This Page