Shard intersection order - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# Shard intersection order

This file builds a combinatorial version of the shard intersection order of type A (in the classification of finite Coxeter groups). This is a lattice on the set of permutations, closely related to noncrossing partitions and the weak order.

For technical reasons, the elements of the posets are not permutations, but can be easily converted from and to permutations:

Sage

    sage: from sage.combinat.shard_order import ShardPosetElement
    sage: p0 = Permutation([1,3,4,2])
    sage: e0 = ShardPosetElement(p0); e0
    (1, 3, 4, 2)
    sage: Permutation(list(e0)) == p0
    True

Python

    >>> from sage.all import *
    >>> from sage.combinat.shard_order import ShardPosetElement
    >>> p0 = Permutation([Integer(1),Integer(3),Integer(4),Integer(2)])
    >>> e0 = ShardPosetElement(p0); e0
    (1, 3, 4, 2)
    >>> Permutation(list(e0)) == p0
    True

See also

A general implementation for all finite Coxeter groups is available as `shard_poset()`

REFERENCES:

[Banc2011]

E. E. Bancroft, Shard Intersections and Cambrian Congruence Classes in Type A., Ph.D. Thesis, North Carolina State University. 2011.

[Pete2013]

T. Kyle Petersen, On the shard intersection order of a Coxeter group, SIAM J. Discrete Math. 27 (2013), no. 4, 1880-1912.

[Read2011]

N. Reading, Noncrossing partitions and the shard intersection order, J. Algebraic Combin., 33 (2011), 483-530.

class sage.combinat.shard_order.ShardPosetElement(p)

  Bases: `tuple`

  An element of the shard poset.

  This is basically a permutation with extra stored arguments:

  - `p` – the permutation itself as a tuple

  - `runs` – the decreasing runs as a tuple of tuples

  - `run_indices` – list; `integer -> index of the run`

  - `dpg` – the transitive closure of the shard preorder graph

  - `spg` – the transitive reduction of the shard preorder graph

  These elements can easily be converted from and to permutations:

  Sage

      sage: from sage.combinat.shard_order import ShardPosetElement
      sage: p0 = Permutation([1,3,4,2])
      sage: e0 = ShardPosetElement(p0); e0
      (1, 3, 4, 2)
      sage: Permutation(list(e0)) == p0
      True

  Python

      >>> from sage.all import *
      >>> from sage.combinat.shard_order import ShardPosetElement
      >>> p0 = Permutation([Integer(1),Integer(3),Integer(4),Integer(2)])
      >>> e0 = ShardPosetElement(p0); e0
      (1, 3, 4, 2)
      >>> Permutation(list(e0)) == p0
      True

sage.combinat.shard_order.shard_poset(n)

  Return the shard intersection order on permutations of size \(n\).

  This is defined on the set of permutations. To every permutation, one can attach a pre-order, using the descending runs and their relative positions.

  The shard intersection order is given by the implication (or refinement) order on the set of pre-orders defined from all permutations.

  This can also be seen in a geometrical way. Every pre-order defines a cone in a vector space of dimension \(n\). The shard poset is given by the inclusion of these cones.

  See also

  `shard_preorder_graph()`

  EXAMPLES:

  Sage

      sage: P = posets.ShardPoset(4); P  # indirect doctest
      Finite poset containing 24 elements
      sage: P.chain_polynomial()
      34*q^4 + 90*q^3 + 79*q^2 + 24*q + 1
      sage: P.characteristic_polynomial()
      q^3 - 11*q^2 + 23*q - 13
      sage: P.zeta_polynomial()
      17/3*q^3 - 6*q^2 + 4/3*q
      sage: P.is_self_dual()
      False

  Python

      >>> from sage.all import *
      >>> P = posets.ShardPoset(Integer(4)); P  # indirect doctest
      Finite poset containing 24 elements
      >>> P.chain_polynomial()
      34*q^4 + 90*q^3 + 79*q^2 + 24*q + 1
      >>> P.characteristic_polynomial()
      q^3 - 11*q^2 + 23*q - 13
      >>> P.zeta_polynomial()
      17/3*q^3 - 6*q^2 + 4/3*q
      >>> P.is_self_dual()
      False

sage.combinat.shard_order.shard_preorder_graph(runs)

  Return the preorder attached to a tuple of decreasing runs.

  This is a directed graph, whose vertices correspond to the runs.

  There is an edge from a run \(R\) to a run \(S\) if \(R\) is before \(S\) in the list of runs and the two intervals defined by the initial and final indices of \(R\) and \(S\) overlap.

  This only depends on the initial and final indices of the runs. For this reason, this input can also be given in that shorten way.

  INPUT:

  - `runs` – either

    - a tuple of tuples, the runs of a permutation, or

    - a tuple of pairs \((i,j)\), each one standing for a run from \(i\) to \(j\)

  OUTPUT: a directed graph, with vertices labelled by integers

  EXAMPLES:

  Sage

      sage: from sage.combinat.shard_order import shard_preorder_graph
      sage: s = Permutation([2,8,3,9,6,4,5,1,7])
      sage: def cut(lr):
      ....:     return tuple((r[0], r[-1]) for r in lr)
      sage: shard_preorder_graph(cut(s.decreasing_runs()))
      Digraph on 5 vertices
      sage: s = Permutation([9,4,3,2,8,6,5,1,7])
      sage: P = shard_preorder_graph(s.decreasing_runs())
      sage: P.is_isomorphic(digraphs.TransitiveTournament(3))
      True

  Python

      >>> from sage.all import *
      >>> from sage.combinat.shard_order import shard_preorder_graph
      >>> s = Permutation([Integer(2),Integer(8),Integer(3),Integer(9),Integer(6),Integer(4),Integer(5),Integer(1),Integer(7)])
      >>> def cut(lr):
      ...     return tuple((r[Integer(0)], r[-Integer(1)]) for r in lr)
      >>> shard_preorder_graph(cut(s.decreasing_runs()))
      Digraph on 5 vertices
      >>> s = Permutation([Integer(9),Integer(4),Integer(3),Integer(2),Integer(8),Integer(6),Integer(5),Integer(1),Integer(7)])
      >>> P = shard_preorder_graph(s.decreasing_runs())
      >>> P.is_isomorphic(digraphs.TransitiveTournament(Integer(3)))
      True