passagemath-graphs 10.6.1rc1__cp310-cp310-musllinux_1_2_aarch64.whl

sage/combinat/shard_order.py

@@ -0,0 +1,239 @@
+# sage_setup: distribution = sagemath-graphs
+r"""
+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: 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
+
+.. SEEALSO::
+
+    A general implementation for all finite Coxeter groups is available as
+    :meth:`~sage.categories.finite_coxeter_groups.FiniteCoxeterGroups.ParentMethods.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.
+"""
+from sage.combinat.posets.posets import Poset
+from sage.graphs.digraph import DiGraph
+from sage.combinat.permutation import Permutations
+
+
+class ShardPosetElement(tuple):
+    r"""
+    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: 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
+    """
+    def __new__(cls, p):
+        r"""
+        Initialization of the underlying tuple.
+
+        TESTS::
+
+            sage: from sage.combinat.shard_order import ShardPosetElement
+            sage: ShardPosetElement(Permutation([1,3,4,2]))
+            (1, 3, 4, 2)
+        """
+        return tuple.__new__(cls, p)
+
+    def __init__(self, p):
+        r"""
+        INPUT:
+
+        - ``p`` -- a permutation
+
+        EXAMPLES::
+
+            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: e0.dpg
+            Transitive closure of : Digraph on 3 vertices
+            sage: e0.spg
+            Digraph on 3 vertices
+        """
+        self.runs = p.decreasing_runs(as_tuple=True)
+        self.run_indices = [0] * (len(p) + 1)
+        for i, bloc in enumerate(self.runs):
+            for j in bloc:
+                self.run_indices[j] = i
+        G = shard_preorder_graph(self.runs)
+        self.dpg = G.transitive_closure()
+        self.spg = G.transitive_reduction()
+
+    def __le__(self, other):
+        """
+        Comparison between two elements of the poset.
+
+        This is the core function in the implementation of the
+        shard intersection order.
+
+        One first compares the number of runs, then the set partitions,
+        then the pre-orders.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.shard_order import ShardPosetElement
+            sage: p0 = Permutation([1,3,4,2])
+            sage: p1 = Permutation([1,4,3,2])
+            sage: e0 = ShardPosetElement(p0)
+            sage: e1 = ShardPosetElement(p1)
+            sage: e0 <= e1
+            True
+            sage: e1 <= e0
+            False
+
+            sage: p0 = Permutation([1,2,5,7,3,4,6,8])
+            sage: p1 = Permutation([2,5,7,3,4,8,6,1])
+            sage: e0 = ShardPosetElement(p0)
+            sage: e1 = ShardPosetElement(p1)
+            sage: e0 <= e1
+            True
+            sage: e1 <= e0
+            False
+        """
+        if not isinstance(other, ShardPosetElement) or len(self) != len(other):
+            raise TypeError("these are not comparable")
+        if self.runs == other.runs:
+            return True
+
+        # r1 must have less runs than r0
+        if len(other.runs) > len(self.runs):
+            return False
+
+        dico1 = other.run_indices
+
+        # conversion: index of run in r0 -> index of run in r1
+        dico0 = [None] * len(self.runs)
+        for i, bloc in enumerate(self.runs):
+            j0 = dico1[bloc[0]]
+            for k in bloc:
+                if dico1[k] != j0:
+                    return False
+            dico0[i] = j0
+
+        # at this point, the set partitions given by tuples are comparable
+        dg0 = self.spg
+        dg1 = other.dpg
+
+        for i, j in dg0.edge_iterator(labels=False):
+            if dico0[i] != dico0[j] and not dg1.has_edge(dico0[i], dico0[j]):
+                return False
+        return True
+
+
+def 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: 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
+    """
+    N = len(runs)
+    dg = DiGraph(N)
+    dg.add_edges((i, j) for i in range(N - 1)
+                 for j in range(i + 1, N)
+                 if runs[i][-1] < runs[j][0] and runs[j][-1] < runs[i][0])
+    return dg
+
+
+def 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.
+
+    .. SEEALSO::
+
+        :func:`~sage.combinat.shard_order.shard_preorder_graph`
+
+    EXAMPLES::
+
+        sage: P = posets.ShardPoset(4); P  # indirect doctest
+        Finite poset containing 24 elements
+        sage: P.chain_polynomial()                                                      # needs sage.libs.flint
+        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()                                                       # needs sage.libs.flint
+        17/3*q^3 - 6*q^2 + 4/3*q
+        sage: P.is_self_dual()
+        False
+    """
+    import operator
+    Sn = [ShardPosetElement(s) for s in Permutations(n)]
+    return Poset([Sn, operator.le], cover_relations=False, facade=True)

sage/combinat/tamari_lattices.py

@@ -0,0 +1,384 @@
+# sage_setup: distribution = sagemath-graphs
+# sage.doctest: needs sage.modules
+r"""
+Generalized Tamari lattices
+
+These lattices depend on three parameters `a`, `b` and `m`, where `a`
+and `b` are positive integers and `m` is a nonnegative
+integer.
+
+The elements are :func:`Dyck paths<sage.combinat.dyck_word.DyckWord>`
+in the `(a \times b)`-rectangle. The order relation depends on `m`.
+
+To use the provided functionality, you should import Generalized
+Tamari lattices by typing::
+
+    sage: from sage.combinat.tamari_lattices import GeneralizedTamariLattice
+
+Then, ::
+
+    sage: GeneralizedTamariLattice(3,2)
+    Finite lattice containing 2 elements
+    sage: GeneralizedTamariLattice(4,3)
+    Finite lattice containing 5 elements
+
+The classical **Tamari lattices** are special cases of this construction and
+are also available directly using the catalogue of posets, as follows::
+
+    sage: posets.TamariLattice(3)
+    Finite lattice containing 5 elements
+
+.. SEEALSO::
+
+    For more detailed information see :meth:`TamariLattice`,
+    :meth:`GeneralizedTamariLattice`.
+"""
+# ****************************************************************************
+#    Copyright (C) 2012-2018 Frédéric Chapoton <chapoton@math.unistra.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from __future__ import annotations
+from sage.combinat.posets.lattices import LatticePoset, MeetSemilattice
+
+
+def paths_in_triangle(i, j, a, b) -> list[tuple[int, ...]]:
+    r"""
+    Return all Dyck paths from `(0,0)` to `(i,j)` in the `(a \times
+    b)`-rectangle.
+
+    This means that at each step of the path, one has `a y \geq b x`.
+
+    A path is represented by a sequence of `0` and `1`, where `0` is an
+    horizontal step `(1,0)` and `1` is a vertical step `(0,1)`.
+
+    INPUT:
+
+    - ``a``, ``b`` -- integers with `a \geq b`
+
+    - ``i``, ``j`` -- nonnegative integers with `1 \geq \frac{j}{b} \geq
+      \frac{i}{a} \geq 0`
+
+    OUTPUT: list of paths
+
+    EXAMPLES::
+
+        sage: from sage.combinat.tamari_lattices import paths_in_triangle
+        sage: paths_in_triangle(2,2,2,2)
+        [(1, 0, 1, 0), (1, 1, 0, 0)]
+        sage: paths_in_triangle(2,3,4,4)
+        [(1, 0, 1, 0, 1), (1, 1, 0, 0, 1), (1, 0, 1, 1, 0),
+        (1, 1, 0, 1, 0), (1, 1, 1, 0, 0)]
+        sage: paths_in_triangle(2,1,4,4)
+        Traceback (most recent call last):
+        ...
+        ValueError: the endpoint is not valid
+        sage: paths_in_triangle(3,2,5,3)
+        [(1, 0, 1, 0, 0), (1, 1, 0, 0, 0)]
+    """
+    if not (b >= j and j * a >= i * b and i >= 0):
+        raise ValueError("the endpoint is not valid")
+
+    if i == 0:
+        return [tuple([1] * j)]
+
+    if (j - 1) * a >= (i) * b:
+        result = [u + (1,) for u in paths_in_triangle(i, j - 1, a, b)]
+        result += [u + (0,) for u in paths_in_triangle(i - 1, j, a, b)]
+        return result
+
+    return [u + (0,) for u in paths_in_triangle(i - 1, j, a, b)]
+
+
+def swap(p, i, m=1) -> tuple[int, ...]:
+    r"""
+    Perform a covering move in the `(a,b)`-Tamari lattice of slope parameter `m`.
+
+    The letter at position `i` in `p` must be a `0`, followed by at
+    least one `1`.
+
+    INPUT:
+
+    - ``p`` -- a Dyck path in the `(a \times b)`-rectangle
+
+    - ``i`` -- integer between `0` and `a+b-1`
+
+    OUTPUT: a Dyck path in the `(a \times b)`-rectangle
+
+    EXAMPLES::
+
+        sage: from sage.combinat.tamari_lattices import swap
+        sage: swap((1,0,1,0,0),1)
+        (1, 1, 0, 0, 0)
+        sage: swap((1,1,0,0,1,1,0,0,0),3)
+        (1, 1, 0, 1, 1, 0, 0, 0, 0)
+        sage: swap((1,0,1,0,1,0,0,0), 1, 1)
+        (1, 1, 0, 0, 1, 0, 0, 0)
+        sage: swap((1,0,1,0,1,0,0,0), 1, 5/3)
+        (1, 1, 0, 1, 0, 0, 0, 0)
+
+
+    TESTS::
+
+        sage: swap((1,0,1,0),6)
+        Traceback (most recent call last):
+        ...
+        ValueError: the index is greater than the length of the path
+        sage: swap((1,1,0,0,1,1,0,0),2)
+        Traceback (most recent call last):
+        ...
+        ValueError: there is no such covering move
+    """
+    if i >= len(p):
+        raise ValueError("the index is greater than the length of the path")
+    if i == len(p) - 1 or p[i + 1] == 0:
+        raise ValueError("there is no such covering move")
+
+    found = False
+    height = 0
+    j = i
+    while not found and j <= len(p) - 2:
+        j += 1
+        if p[j]:
+            height += m
+        else:
+            height -= 1
+        if height <= 0:
+            found = True
+    q = list(p)
+    for k in range(i, j):
+        q[k] = p[k + 1]
+    q[j] = 0
+    return tuple(q)
+
+
+def GeneralizedTamariLattice(a, b, m=1):
+    r"""
+    Return the `(a,b)`-Tamari lattice of parameter `m`.
+
+    INPUT:
+
+    - ``a``, ``b`` -- integers with `a \geq b`
+
+    - ``m`` -- a nonnegative rational number such that `a \geq b m`
+
+    OUTPUT:
+
+    - a finite lattice (special case of the alt `\nu`-Tamari lattices in [CC2023]_)
+
+    The elements of the lattice are
+    :func:`Dyck paths<sage.combinat.dyck_word.DyckWord>` in the
+    `(a \times b)`-rectangle.
+
+    The parameter `m` (slope) is used only to define the covering relations.
+    When the slope `m` is `0`, two paths are comparable if and only if
+    one is always above the other.
+
+    The usual :wikipedia:`Tamari lattice<Tamari_lattice>` of index `b`
+    is the special case `a=b+1` and `m=1`.
+
+    Other special cases give the `m`-Tamari lattices studied in [BMFPR2011]_,
+    or the rational Tamari lattices when a and b are coprime and m = a/b (see [PRV2017]_).
+
+    EXAMPLES::
+
+        sage: from sage.combinat.tamari_lattices import GeneralizedTamariLattice
+        sage: GeneralizedTamariLattice(3,2)
+        Finite lattice containing 2 elements
+        sage: GeneralizedTamariLattice(4,3)
+        Finite lattice containing 5 elements
+        sage: GeneralizedTamariLattice(7,5,2)
+        Traceback (most recent call last):
+        ...
+        ValueError: the condition a>=b*m does not hold
+        sage: P = GeneralizedTamariLattice(5,3); P
+        Finite lattice containing 7 elements
+        sage: P = GeneralizedTamariLattice(5, 3, m=5/3); P
+        Finite lattice containing 7 elements
+
+
+    TESTS::
+
+        sage: P.coxeter_transformation()**18 == 1                                       # needs sage.libs.flint
+        True
+
+    REFERENCES:
+
+    - [BMFPR2011]_
+
+    - [PRV2017]_
+
+    - [CC2023]_
+    """
+    if a < b * m:
+        raise ValueError("the condition a>=b*m does not hold")
+
+    def covers(p):
+        return [swap(p, i, m) for i in range(len(p) - 1)
+                if not p[i] and p[i + 1]]
+    return LatticePoset({p: covers(p)
+                         for p in paths_in_triangle(a, b, a, b)}, check=False)
+
+
+def TamariLattice(n, m=1):
+    r"""
+    Return the `n`-th Tamari lattice.
+
+    Using the slope parameter `m`, one can also get the `m`-Tamari lattices.
+
+    INPUT:
+
+    - ``n`` -- nonnegative integer (the index)
+
+    - ``m`` -- nonnegative integer (the slope, default: 1)
+
+    OUTPUT: a finite lattice
+
+    In the usual case, the elements of the lattice are :func:`Dyck
+    paths<sage.combinat.dyck_word.DyckWord>` in the `(n+1 \times
+    n)`-rectangle. For a general slope `m`, the elements are Dyck
+    paths in the `(m n+1 \times n)`-rectangle.
+
+    See :wikipedia:`Tamari lattice<Tamari_lattice>` for mathematical
+    background.
+
+    EXAMPLES::
+
+        sage: posets.TamariLattice(3)
+        Finite lattice containing 5 elements
+
+        sage: posets.TamariLattice(3, 2)
+        Finite lattice containing 12 elements
+
+    REFERENCES:
+
+    - [BMFPR2011]_
+    """
+    return GeneralizedTamariLattice(m * n + 1, n, m)
+
+
+# a variation : the Dexter meet-semilattices
+
+
+def swap_dexter(p, i) -> list[tuple[int, ...]]:
+    r"""
+    Perform covering moves in the `(a,b)`-Dexter posets.
+
+    The letter at position `i` in `p` must be a `0`, followed by at
+    least one `1`.
+
+    INPUT:
+
+    - ``p`` -- a Dyck path in the `(a \times b)`-rectangle
+
+    - ``i`` -- integer between `0` and `a+b-1`
+
+    OUTPUT:
+
+    - a list of Dyck paths in the `(a \times b)`-rectangle
+
+    EXAMPLES::
+
+        sage: from sage.combinat.tamari_lattices import swap_dexter
+        sage: swap_dexter((1,0,1,0,0),1)
+        [(1, 1, 0, 0, 0)]
+        sage: swap_dexter((1,1,0,0,1,1,0,0,0),3)
+        [(1, 1, 0, 1, 1, 0, 0, 0, 0), (1, 1, 1, 1, 0, 0, 0, 0, 0)]
+        sage: swap_dexter((1,1,0,1,0,0,0),2)
+        []
+
+    TESTS::
+
+        sage: swap_dexter((1,0,1,0,0),6)
+        Traceback (most recent call last):
+        ...
+        ValueError: the index is greater than the length of the path
+
+        sage: swap_dexter((1,1,0,0,1,1,0,0,0),2)
+        Traceback (most recent call last):
+        ...
+        ValueError: there is no such covering move
+    """
+    m = 1
+
+    if i >= len(p):
+        raise ValueError("the index is greater than the length of the path")
+    if i == len(p) - 1 or p[i + 1] == 0:
+        raise ValueError("there is no such covering move")
+
+    found = False
+    height = 0
+    j = i
+    while not found and j <= len(p) - 2:
+        j += 1
+        if p[j]:
+            height += m
+        else:
+            height -= 1
+        if height == 0:
+            found = True
+    if not (j == len(p) - 2 or p[j + 1]):  # forbidden moves
+        return []
+
+    resu = []
+    tp = tuple(p)
+    for deb in range(i, 0, -1):
+        if not p[deb]:
+            q = tp[:deb] + tp[i + 1: j + 1] + tp[deb: i + 1] + tp[j + 1:]
+            resu.append(q)
+        else:
+            break
+    return resu
+
+
+def DexterSemilattice(n):
+    r"""
+    Return the `n`-th Dexter meet-semilattice.
+
+    INPUT:
+
+    - ``n`` -- nonnegative integer (the index)
+
+    OUTPUT: a finite meet-semilattice
+
+    The elements of the semilattice are :func:`Dyck
+    paths<sage.combinat.dyck_word.DyckWord>` in the `(n+1 \times
+    n)`-rectangle.
+
+    EXAMPLES::
+
+        sage: posets.DexterSemilattice(3)
+        Finite meet-semilattice containing 5 elements
+
+        sage: P = posets.DexterSemilattice(4); P
+        Finite meet-semilattice containing 14 elements
+        sage: len(P.maximal_chains())
+        15
+        sage: len(P.maximal_elements())
+        4
+        sage: P.chain_polynomial()                                                      # needs sage.libs.flint
+        q^5 + 19*q^4 + 47*q^3 + 42*q^2 + 14*q + 1
+
+    REFERENCES:
+
+    - [Cha18]_
+    """
+    a = n + 1
+    b = n
+
+    def covers_dexter(p):
+        data = [swap_dexter(p, i) for i in range(len(p) - 1)
+                if not p[i] and p[i + 1]]
+        return [cov for L in data for cov in L]
+    return MeetSemilattice({p: covers_dexter(p)
+                            for p in paths_in_triangle(a, b, a, b)},
+                           check=False)