### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »

# Set Partitions

AUTHORS:

- Mike Hansen
- MuPAD-Combinat developers (for algorithms and design inspiration).
- Travis Scrimshaw (2013-02-28): Removed `CombinatorialClass` and added entry point through `SetPartition`.

class `sage.combinat.set_partition.``SetPartition`(parent, s)

  Bases: `sage.structure.list_clone.ClonableArray`

  A partition of a set.

  A set partition \(p\) of a set \(S\) is a partition of \(S\) into subsets called parts and represented as a set of sets. By extension, a set partition of a nonnegative integer \(n\) is the set partition of the integers from 1 to \(n\). The number of set partitions of \(n\) is called the \(n\)-th Bell number.

  There is a natural integer partition associated with a set partition, namely the nonincreasing sequence of sizes of all its parts.

  There is a classical lattice associated with all set partitions of \(n\). The infimum of two set partitions is the set partition obtained by intersecting all the parts of both set partitions. The supremum is obtained by transitive closure of the relation \(i\) related to \(j\) if and only if they are in the same part in at least one of the set partitions.

  We will use terminology from partitions, in particular the length of a set partition \(A = \{A_1, \ldots, A_k\}\) is the number of parts of \(A\) and is denoted by \(|A| := k\). The size of \(A\) is the cardinality of \(S\). We will also sometimes use the notation \([n] := \{1, 2, \ldots, n\}\).

  EXAMPLES:

  There are 5 set partitions of the set \(\{1,2,3\}\):

      sage: SetPartitions(3).cardinality()
      5

  Here is the list of them:

      sage: SetPartitions(3).list()
      [{{1, 2, 3}},
       {{1}, {2, 3}},
       {{1, 3}, {2}},
       {{1, 2}, {3}},
       {{1}, {2}, {3}}]

  There are 6 set partitions of \(\{1,2,3,4\}\) whose underlying partition is \([2, 1, 1]\):

      sage: SetPartitions(4, [2,1,1]).list()
      [{{1}, {2}, {3, 4}},
       {{1}, {2, 4}, {3}},
       {{1}, {2, 3}, {4}},
       {{1, 4}, {2}, {3}},
       {{1, 3}, {2}, {4}},
       {{1, 2}, {3}, {4}}]

  Since trac ticket #14140, we can create a set partition directly by `SetPartition`, which creates the base set by taking the union of the parts passed in:

      sage: s = SetPartition([[1,3],[2,4]]); s
      {{1, 3}, {2, 4}}
      sage: s.parent()
      Set partitions

  `apply_permutation`(p)

    Apply `p` to the underlying set of `self`.

    INPUT:

    - `p` – A permutation

    EXAMPLES:

        sage: x = SetPartition([[1,2], [3,5,4]])
        sage: p = Permutation([2,1,4,5,3])
        sage: x.apply_permutation(p)
        {{1, 2}, {3, 4, 5}}
        sage: q = Permutation([3,2,1,5,4])
        sage: x.apply_permutation(q)
        {{1, 4, 5}, {2, 3}}

  `base_set`()

    Return the base set of `self`, which is the union of all parts of `self`.

    EXAMPLES:

        sage: SetPartition([[1], [2,3], [4]]).base_set()
        {1, 2, 3, 4}
        sage: SetPartition([[1,2,3,4]]).base_set()
        {1, 2, 3, 4}
        sage: SetPartition([]).base_set()
        {}

  `base_set_cardinality`()

    Return the cardinality of the base set of `self`, which is the sum of the sizes of the parts of `self`.

    This is also known as the size (sometimes the weight) of a set partition.

    EXAMPLES:

        sage: SetPartition([[1], [2,3], [4]]).base_set_cardinality()
        4
        sage: SetPartition([[1,2,3,4]]).base_set_cardinality()
        4

  `cardinality`()

    Returns the len of `self`

    EXAMPLES:

        sage: from sage.structure.list_clone_demo import IncreasingArrays
        sage: len(IncreasingArrays()([1,2,3]))
        3

  `check`()

    Check that we are a valid ordered set partition.

    EXAMPLES:

        sage: OS = OrderedSetPartitions(4)
        sage: s = OS([[1, 3], [2, 4]])
        sage: s.check()

  `coarsenings`()

    Return a list of coarsenings of `self`.

    EXAMPLES:

        sage: SetPartition([[1,3],[2,4]]).coarsenings()
        [{{1, 2, 3, 4}}, {{1, 3}, {2, 4}}]
        sage: SetPartition([[1],[2,4],[3]]).coarsenings()
        [{{1, 2, 3, 4}},
         {{1}, {2, 3, 4}},
         {{1, 3}, {2, 4}},
         {{1, 2, 4}, {3}},
         {{1}, {2, 4}, {3}}]
        sage: SetPartition([]).coarsenings()
        [{}]

  `inf`(other)

    The product of the set partitions `self` and `other`.

    The product of two set partitions \(B\) and \(C\) is defined as the set partition whose parts are the nonempty intersections between each part of \(B\) and each part of \(C\). This product is also the infimum of \(B\) and \(C\) in the classical set partition lattice (that is, the coarsest set partition which is finer than each of \(B\) and \(C\)). Consequently, `inf` acts as an alias for this method.

    See also

    `sup()`

    EXAMPLES:

        sage: x = SetPartition([ [1,2], [3,5,4] ])
        sage: y = SetPartition(( (3,1,2), (5,4) ))
        sage: x * y
        {{1, 2}, {3}, {4, 5}}

        sage: S = SetPartitions(4)
        sage: sp1 = S([[2,3,4], [1]])
        sage: sp2 = S([[1,3], [2,4]])
        sage: s = S([[2,4], [3], [1]])
        sage: sp1.inf(sp2) == s
        True

    TESTS:

    Here is a different implementation of the `__mul__` method (one that was formerly used for the `inf` method, before it was realized that the methods do the same thing):

        sage: def mul2(s, t):
        ....:     temp = [ss.intersection(ts) for ss in s for ts in t]
        ....:     temp = filter(lambda x: x != Set([]), temp)
        ....:     return s.__class__(s.parent(), temp)

    Let us check that this gives the same as `__mul__` on set partitions of \(\{1, 2, 3, 4\}\):

        sage: all( all( mul2(s, t) == s * t for s in SetPartitions(4) )
        ....:      for t in SetPartitions(4) )
        True

  `is_atomic`()

    Return if `self` is an atomic set partition.

    A (standard) set partition \(A\) can be split if there exist \(j < i\) such that \(\max(A_j) < \min(A_i)\) where \(A\) is ordered by minimal elements. This means we can write \(A = B | C\) for some nonempty set partitions \(B\) and \(C\). We call a set partition atomic if it cannot be split and is nonempty. Here, the pipe symbol \(|\) is as defined in method `pipe()`.

    EXAMPLES:

        sage: SetPartition([[1,3], [2]]).is_atomic()
        True
        sage: SetPartition([[1,3], [2], [4]]).is_atomic()
        False
        sage: SetPartition([[1], [2,4], [3]]).is_atomic()
        False
        sage: SetPartition([[1,2,3,4]]).is_atomic()
        True
        sage: SetPartition([[1, 4], [2], [3]]).is_atomic()
        True
        sage: SetPartition([]).is_atomic()
        False

  `is_noncrossing`()

    Check if `self` is noncrossing.

    EXAMPLES:

        sage: x = SetPartition([[1,2],[3,4]])
        sage: x.is_noncrossing()
        True
        sage: x = SetPartition([[1,3],[2,4]])
        sage: x.is_noncrossing()
        False

    AUTHOR: Florent Hivert

  `ordered_set_partition_action`(s)

    Return the action of an ordered set partition `s` on `self`.

    Let \(A = \{A_1, A_2, \ldots, A_k\}\) be a set partition of some set \(S\) and \(s\) be an ordered set partition (i.e., set composition) of a subset of \([k]\). Let \(A^{\downarrow}\) denote the standardization of \(A\), and \(A_{\{ i_1, i_2, \ldots, i_m \}}\) denote the sub-partition \(\{A_{i_1}, A_{i_2}, \ldots, A_{i_m}\}\) for any subset \(\{i_1, \ldots, i_m\}\) of \(\{1, \ldots, k\}\). We define the set partition \(s(A)\) by

    \[s(A) = A_{s_1}^{\downarrow} | A_{s_2}^{\downarrow} | \cdots | A_{s_q}^{\downarrow}.\]

    where \(s = (s_1, s_2, \ldots, s_q)\). Here, the pipe symbol \(|\) is as defined in method `pipe()`.

    This is \(s[A]\) in section 2.3 in [LM2011].

    INPUT:

    - `s` – an ordered set partition with base set a subset of \(\{1, \ldots, k\}\)

    EXAMPLES:

        sage: A = SetPartition([[1], [2,4], [3]])
        sage: s = OrderedSetPartition([[1,3], [2]])
        sage: A.ordered_set_partition_action(s)
        {{1}, {2}, {3, 4}}
        sage: s = OrderedSetPartition([[2,3], [1]])
        sage: A.ordered_set_partition_action(s)
        {{1, 3}, {2}, {4}}

    We create Figure 1 in [LM2011] (we note that there is a typo in the lower-left corner of the table in the published version of the paper, whereas the arXiv version gives the correct partition):

        sage: A = SetPartition([[1,3], [2,9], [4,5,8], [7]])
        sage: B = SetPartition([[1,3], [2,8], [4,5,6], [7]])
        sage: C = SetPartition([[1,5], [2,8], [3,4,6], [7]])
        sage: s = OrderedSetPartition([[1,3], [2]])
        sage: t = OrderedSetPartition([[2], [3,4]])
        sage: u = OrderedSetPartition([[1], [2,3,4]])
        sage: A.ordered_set_partition_action(s)
        {{1, 2}, {3, 4, 5}, {6, 7}}
        sage: A.ordered_set_partition_action(t)
        {{1, 2}, {3, 4, 6}, {5}}
        sage: A.ordered_set_partition_action(u)
        {{1, 2}, {3, 8}, {4, 5, 7}, {6}}
        sage: B.ordered_set_partition_action(s)
        {{1, 2}, {3, 4, 5}, {6, 7}}
        sage: B.ordered_set_partition_action(t)
        {{1, 2}, {3, 4, 5}, {6}}
        sage: B.ordered_set_partition_action(u)
        {{1, 2}, {3, 8}, {4, 5, 6}, {7}}
        sage: C.ordered_set_partition_action(s)
        {{1, 4}, {2, 3, 5}, {6, 7}}
        sage: C.ordered_set_partition_action(t)
        {{1, 2}, {3, 4, 5}, {6}}
        sage: C.ordered_set_partition_action(u)
        {{1, 2}, {3, 8}, {4, 5, 6}, {7}}

    REFERENCES:

    [LM2011] | (1, 2) A. Lauve, M. Mastnak. The primitives and antipode in the Hopf algebra of symmetric functions in noncommuting variables. Advances in Applied Mathematics. 47 (2011). 536-544. Arxiv 1006.0367v3 doi:10.1016/j.aam.2011.01.002.

  `pipe`(other)

    Return the pipe of the set partitions `self` and `other`.

    The pipe of two set partitions is defined as follows:

    For any integer \(k\) and any subset \(I\) of \(\ZZ\), let \(I + k\) denote the subset of \(\ZZ\) obtained by adding \(k\) to every element of \(k\).

    If \(B\) and \(C\) are set partitions of \([n]\) and \([m]\), respectively, then the pipe of \(B\) and \(C\) is defined as the set partition

    \[\{ B_1, B_2, \ldots, B_b, C_1 + n, C_2 + n, \ldots, C_c + n \}\]

    of \([n+m]\), where \(B = \{ B_1, B_2, \ldots, B_b \}\) and \(C = \{ C_1, C_2, \ldots, C_c \}\). This pipe is denoted by \(B | C\).

    EXAMPLES:

        sage: SetPartition([[1,3],[2,4]]).pipe(SetPartition([[1,3],[2]]))
        {{1, 3}, {2, 4}, {5, 7}, {6}}
        sage: SetPartition([]).pipe(SetPartition([[1,2],[3,5],[4]]))
        {{1, 2}, {3, 5}, {4}}
        sage: SetPartition([[1,2],[3,5],[4]]).pipe(SetPartition([]))
        {{1, 2}, {3, 5}, {4}}
        sage: SetPartition([[1,2],[3]]).pipe(SetPartition([[1]]))
        {{1, 2}, {3}, {4}}

  `refinements`()

    Return a list of refinements of `self`.

    EXAMPLES:

        sage: SetPartition([[1,3],[2,4]]).refinements()
        [{{1, 3}, {2, 4}},
         {{1, 3}, {2}, {4}},
         {{1}, {2, 4}, {3}},
         {{1}, {2}, {3}, {4}}]
        sage: SetPartition([[1],[2,4],[3]]).refinements()
        [{{1}, {2, 4}, {3}}, {{1}, {2}, {3}, {4}}]
        sage: SetPartition([]).refinements()
        [{}]

  `restriction`(I)

    Return the restriction of `self` to a subset `I` (which is given as a set or list or any other iterable).

    EXAMPLES:

        sage: A = SetPartition([[1], [2,3]])
        sage: A.restriction([1,2])
        {{1}, {2}}
        sage: A.restriction([2,3])
        {{2, 3}}
        sage: A.restriction([])
        {}
        sage: A.restriction([4])
        {}

  `shape`()

    Return the integer partition whose parts are the sizes of the sets in `self`.

    EXAMPLES:

        sage: S = SetPartitions(5)
        sage: x = S([[1,2], [3,5,4]])
        sage: x.shape()
        [3, 2]
        sage: y = S([[2], [3,1], [5,4]])
        sage: y.shape()
        [2, 2, 1]

  `shape_partition`()

    Return the integer partition whose parts are the sizes of the sets in `self`.

    EXAMPLES:

        sage: S = SetPartitions(5)
        sage: x = S([[1,2], [3,5,4]])
        sage: x.shape()
        [3, 2]
        sage: y = S([[2], [3,1], [5,4]])
        sage: y.shape()
        [2, 2, 1]

  `size`()

    Return the cardinality of the base set of `self`, which is the sum of the sizes of the parts of `self`.

    This is also known as the size (sometimes the weight) of a set partition.

    EXAMPLES:

        sage: SetPartition([[1], [2,3], [4]]).base_set_cardinality()
        4
        sage: SetPartition([[1,2,3,4]]).base_set_cardinality()
        4

  `standard_form`()

    Return `self` as a list of lists.

    This is not related to standard set partitions (which simply means set partitions of \([n] = \{ 1, 2, \ldots , n \}\) for some integer \(n\)) or standardization (`standardization()`).

    EXAMPLES:

        sage: [x.standard_form() for x in SetPartitions(4, [2,2])]
        [[[1, 2], [3, 4]], [[1, 3], [2, 4]], [[1, 4], [2, 3]]]

  `standardization`()

    Return the standardization of `self`.

    Given a set partition \(A = \{A_1, \ldots, A_n\}\) of an ordered set \(S\), the standardization of \(A\) is the set partition of \(\{1, 2, \ldots, |S|\}\) obtained by replacing the elements of the parts of \(A\) by the integers \(1, 2, \ldots, |S|\) in such a way that their relative order is preserved (i. e., the smallest element in the whole set partition is replaced by \(1\), the next-smallest by \(2\), and so on).

    EXAMPLES:

        sage: SetPartition([[4], [1, 3]]).standardization()
        {{1, 2}, {3}}
        sage: SetPartition([[4], [6, 3]]).standardization()
        {{1, 3}, {2}}
        sage: SetPartition([]).standardization()
        {}

  `strict_coarsenings`()

    Return all strict coarsenings of `self`.

    Strict coarsening is the binary relation on set partitions defined as the transitive-and-reflexive closure of the relation \(\prec\) defined as follows: For two set partitions \(A\) and \(B\), we have \(A \prec B\) if there exist parts \(A_i, A_j\) of \(A\) such that \(\max(A_i) < \min(A_j)\) and \(B = A \setminus \{A_i, A_j\} \cup \{ A_i \cup A_j \}\).

    EXAMPLES:

        sage: A = SetPartition([[1],[2,3],[4]])
        sage: A.strict_coarsenings()
        [{{1}, {2, 3}, {4}}, {{1, 2, 3}, {4}}, {{1, 4}, {2, 3}},
         {{1}, {2, 3, 4}}, {{1, 2, 3, 4}}]
        sage: SetPartition([[1],[2,4],[3]]).strict_coarsenings()
        [{{1}, {2, 4}, {3}}, {{1, 2, 4}, {3}}, {{1, 3}, {2, 4}}]
        sage: SetPartition([]).strict_coarsenings()
        [{}]

  `sup`(t)

    Return the supremum of `self` and `t` in the classical set partition lattice.

    The supremum of two set partitions \(B\) and \(C\) is obtained as the transitive closure of the relation which relates \(i\) to \(j\) if and only if \(i\) and \(j\) are in the same part in at least one of the set partitions \(B\) and \(C\).

    See also

    `__mul__()`

    EXAMPLES:

        sage: S = SetPartitions(4)
        sage: sp1 = S([[2,3,4], [1]])
        sage: sp2 = S([[1,3], [2,4]])
        sage: s = S([[1,2,3,4]])
        sage: sp1.sup(sp2) == s
        True

  `to_partition`()

    Return the integer partition whose parts are the sizes of the sets in `self`.

    EXAMPLES:

        sage: S = SetPartitions(5)
        sage: x = S([[1,2], [3,5,4]])
        sage: x.shape()
        [3, 2]
        sage: y = S([[2], [3,1], [5,4]])
        sage: y.shape()
        [2, 2, 1]

  `to_permutation`()

    Convert `self` to a permutation by considering the partitions as cycles.

    EXAMPLES:

        sage: s = SetPartition([[1,3],[2,4]])
        sage: s.to_permutation()
        [3, 4, 1, 2]

class `sage.combinat.set_partition.``SetPartitions`

  Bases: `sage.structure.parent.Parent`, `sage.structure.unique_representation.UniqueRepresentation`

  An (unordered) partition of a set \(S\) is a set of pairwise disjoint nonempty subsets with union \(S\), and is represented by a sorted list of such subsets.

  `SetPartitions(s)` returns the class of all set partitions of the set `s`, which can be given as a set or a string; if a string, each character is considered an element.

  `SetPartitions(n)`, where `n` is an integer, returns the class of all set partitions of the set \(\{1, 2, \ldots, n\}\).

  You may specify a second argument \(k\). If \(k\) is an integer, `SetPartitions` returns the class of set partitions into \(k\) parts; if it is an integer partition, `SetPartitions` returns the class of set partitions whose block sizes correspond to that integer partition.

  The Bell number \(B_n\), named in honor of Eric Temple Bell, is the number of different partitions of a set with \(n\) elements.

  EXAMPLES:

      sage: S = [1,2,3,4]
      sage: SetPartitions(S,2)
      Set partitions of {1, 2, 3, 4} with 2 parts
      sage: SetPartitions([1,2,3,4], [3,1]).list()
      [{{1}, {2, 3, 4}}, {{1, 3, 4}, {2}}, {{1, 2, 4}, {3}}, {{1, 2, 3}, {4}}]
      sage: SetPartitions(7, [3,3,1]).cardinality()
      70

  In strings, repeated letters are not considered distinct as of trac ticket #14140:

      sage: SetPartitions('abcde').cardinality()
      52
      sage: SetPartitions('aabcd').cardinality()
      15

  REFERENCES:

  - Wikipedia article Partition_of_a_set
  `Element`

    alias of `SetPartition`

  `is_less_than`(s, t)

    Check if \(s < t\) in the refinement ordering on set partitions.

    This means that \(s\) is a refinement of \(t\) and satisfies \(s \neq t\).

    A set partition \(s\) is said to be a refinement of a set partition \(t\) of the same set if and only if each part of \(s\) is a subset of a part of \(t\).

    EXAMPLES:

        sage: S = SetPartitions(4)
        sage: s = S([[1,3],[2,4]])
        sage: t = S([[1],[2],[3],[4]])
        sage: S.is_less_than(t, s)
        True
        sage: S.is_less_than(s, t)
        False
        sage: S.is_less_than(s, s)
        False

  `is_strict_refinement`(s, t)

    Return `True` if `s` is a strict refinement of `t` and satisfies \(s \neq t\).

    A set partition \(s\) is said to be a strict refinement of a set partition \(t\) of the same set if and only if one can obtain \(t\) from \(s\) by repeatedly combining pairs of parts whose convex hulls don’t intersect (i. e., whenever we are combining two parts, the maximum of each of them should be smaller than the minimum of the other).

    EXAMPLES:

        sage: S = SetPartitions(4)
        sage: s = S([[1],[2],[3],[4]])
        sage: t = S([[1,3],[2,4]])
        sage: u = S([[1,2,3,4]])
        sage: S.is_strict_refinement(s, t)
        True
        sage: S.is_strict_refinement(t, u)
        False
        sage: A = SetPartition([[1,3],[2,4]])
        sage: B = SetPartition([[1,2,3,4]])
        sage: S.is_strict_refinement(s, A)
        True
        sage: S.is_strict_refinement(t, B)
        False

  `lt`(s, t)

    Check if \(s < t\) in the refinement ordering on set partitions.

    This means that \(s\) is a refinement of \(t\) and satisfies \(s \neq t\).

    A set partition \(s\) is said to be a refinement of a set partition \(t\) of the same set if and only if each part of \(s\) is a subset of a part of \(t\).

    EXAMPLES:

        sage: S = SetPartitions(4)
        sage: s = S([[1,3],[2,4]])
        sage: t = S([[1],[2],[3],[4]])
        sage: S.is_less_than(t, s)
        True
        sage: S.is_less_than(s, t)
        False
        sage: S.is_less_than(s, s)
        False

class `sage.combinat.set_partition.``SetPartitions_all`

  Bases: `sage.combinat.set_partition.SetPartitions`

  All set partitions.

class `sage.combinat.set_partition.``SetPartitions_set`(s)

  Bases: `sage.combinat.set_partition.SetPartitions`

  Set partitions of a fixed set \(S\).

  `base_set`()

    Return the base set of `self`.

    EXAMPLES:

        sage: SetPartitions(3).base_set()
        {1, 2, 3}

  `base_set_cardinality`()

    Return the cardinality of the base set of `self`.

    EXAMPLES:

        sage: SetPartitions(3).base_set_cardinality()
        3

  `cardinality`()

    Return the number of set partitions of the set \(S\).

    The cardinality is given by the \(n\)-th Bell number where \(n\) is the number of elements in the set \(S\).

    EXAMPLES:

        sage: SetPartitions([1,2,3,4]).cardinality()
        15
        sage: SetPartitions(3).cardinality()
        5
        sage: SetPartitions(3,2).cardinality()
        3
        sage: SetPartitions([]).cardinality()
        1

class `sage.combinat.set_partition.``SetPartitions_setn`(s, n)

  Bases: `sage.combinat.set_partition.SetPartitions_set`

  TESTS:

      sage: S = SetPartitions(5, 3)
      sage: TestSuite(S).run()

  `cardinality`()

    The Stirling number of the second kind is the number of partitions of a set of size \(n\) into \(k\) blocks.

    EXAMPLES:

        sage: SetPartitions(5, 3).cardinality()
        25
        sage: stirling_number2(5,3)
        25

class `sage.combinat.set_partition.``SetPartitions_setparts`(s, parts)

  Bases: `sage.combinat.set_partition.SetPartitions_set`

  Class of all set partitions with fixed partition sizes corresponding to an integer partition \(\lambda\).

  `cardinality`()

    Return the cardinality of `self`.

    EXAMPLES:

        sage: SetPartitions(3, [2,1]).cardinality()
        3

`sage.combinat.set_partition.``cyclic_permutations_of_set_partition`(set_part)

  Returns all combinations of cyclic permutations of each cell of the set partition.

  AUTHORS:

  - Robert L. Miller

  EXAMPLES:

      sage: from sage.combinat.set_partition import cyclic_permutations_of_set_partition
      sage: cyclic_permutations_of_set_partition([[1,2,3,4],[5,6,7]])
      [[[1, 2, 3, 4], [5, 6, 7]],
       [[1, 2, 4, 3], [5, 6, 7]],
       [[1, 3, 2, 4], [5, 6, 7]],
       [[1, 3, 4, 2], [5, 6, 7]],
       [[1, 4, 2, 3], [5, 6, 7]],
       [[1, 4, 3, 2], [5, 6, 7]],
       [[1, 2, 3, 4], [5, 7, 6]],
       [[1, 2, 4, 3], [5, 7, 6]],
       [[1, 3, 2, 4], [5, 7, 6]],
       [[1, 3, 4, 2], [5, 7, 6]],
       [[1, 4, 2, 3], [5, 7, 6]],
       [[1, 4, 3, 2], [5, 7, 6]]]

`sage.combinat.set_partition.``cyclic_permutations_of_set_partition_iterator`(set_part)

  Iterates over all combinations of cyclic permutations of each cell of the set partition.

  AUTHORS:

  - Robert L. Miller

  EXAMPLES:

      sage: from sage.combinat.set_partition import cyclic_permutations_of_set_partition_iterator
      sage: list(cyclic_permutations_of_set_partition_iterator([[1,2,3,4],[5,6,7]]))
      [[[1, 2, 3, 4], [5, 6, 7]],
       [[1, 2, 4, 3], [5, 6, 7]],
       [[1, 3, 2, 4], [5, 6, 7]],
       [[1, 3, 4, 2], [5, 6, 7]],
       [[1, 4, 2, 3], [5, 6, 7]],
       [[1, 4, 3, 2], [5, 6, 7]],
       [[1, 2, 3, 4], [5, 7, 6]],
       [[1, 2, 4, 3], [5, 7, 6]],
       [[1, 3, 2, 4], [5, 7, 6]],
       [[1, 3, 4, 2], [5, 7, 6]],
       [[1, 4, 2, 3], [5, 7, 6]],
       [[1, 4, 3, 2], [5, 7, 6]]]

`sage.combinat.set_partition.``inf`(s, t)

  Deprecated in trac ticket #14140. Use `SetPartition.inf()` instead.

  EXAMPLES:

      sage: sp1 = Set([Set([2,3,4]),Set([1])])
      sage: sp2 = Set([Set([1,3]), Set([2,4])])
      sage: s = Set([ Set([2,4]), Set([3]), Set([1])]) #{{2, 4}, {3}, {1}}
      sage: sage.combinat.set_partition.inf(sp1, sp2) == s
      doctest:...: DeprecationWarning: inf(s, t) is deprecated. Use s.inf(t) instead.
      See http://trac.sagemath.org/14140 for details.
      True

`sage.combinat.set_partition.``less`(s, t)

  Deprecated in trac ticket #14140. Use `SetPartitions.is_less_than()` instead.

  EXAMPLES:

      sage: z = SetPartitions(3).list()
      sage: sage.combinat.set_partition.less(z[0], z[1])
      doctest:...: DeprecationWarning: less(s, t) is deprecated. Use SetPartitions.is_less_tan(s, t) instead.
      See http://trac.sagemath.org/14140 for details.
      False

`sage.combinat.set_partition.``standard_form`(sp)

  Deprecated in trac ticket #14140. Use `SetPartition.standard_form()` instead.

  EXAMPLES:

      sage: map(sage.combinat.set_partition.standard_form, SetPartitions(4, [2,2]))
      doctest:...: DeprecationWarning: standard_form(sp) is deprecated. Use sp.standard_form() instead.
      See http://trac.sagemath.org/14140 for details.
      [[[1, 2], [3, 4]], [[1, 3], [2, 4]], [[1, 4], [2, 3]]]

`sage.combinat.set_partition.``sup`(s, t)

  Deprecated in trac ticket #14140. Use `SetPartition.sup()` instead.

  EXAMPLES:

      sage: sp1 = Set([Set([2,3,4]),Set([1])])
      sage: sp2 = Set([Set([1,3]), Set([2,4])])
      sage: s = Set([ Set([1,2,3,4]) ])
      sage: sage.combinat.set_partition.sup(sp1, sp2) == s
      doctest:...: DeprecationWarning: sup(s, t) is deprecated. Use s.sup(t) instead.
      See http://trac.sagemath.org/14140 for details.
      True

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »