passagemath-graphs 10.6.1rc1__cp310-cp310-musllinux_1_2_aarch64.whl

sage/combinat/interval_posets.py

@@ -0,0 +1,3908 @@
+# sage_setup: distribution = sagemath-graphs
+r"""
+Tamari Interval-posets
+
+This module implements Tamari interval-posets: combinatorial objects which
+represent intervals of the Tamari order. They have been introduced in
+[CP2015]_ and allow for many combinatorial operations on Tamari intervals.
+In particular, they are linked to :class:`DyckWords` and :class:`BinaryTrees`.
+An introduction into Tamari interval-posets is given in Chapter 7
+of [Pons2013]_.
+
+The Tamari lattice can be defined as a lattice structure on either of several
+classes of Catalan objects, especially binary trees and Dyck paths
+[Tam1962]_ [HT1972]_ [Sta-EC2]_. An interval can be seen as
+a pair of comparable elements. The number of intervals has been given in
+[Cha2008]_.
+
+AUTHORS:
+
+- Viviane Pons 2014: initial implementation
+- Frédéric Chapoton 2014: review
+- Darij Grinberg 2014: review
+- Travis Scrimshaw 2014: review
+"""
+# ****************************************************************************
+#       Copyright (C) 2013 Viviane Pons <viviane.pons@univie.ac.at>,
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from __future__ import annotations
+from collections.abc import Iterator
+
+from sage.categories.enumerated_sets import EnumeratedSets
+from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
+from sage.categories.posets import Posets
+from sage.categories.monoids import Monoids
+from sage.combinat.posets.posets import Poset, FinitePoset
+from sage.categories.finite_posets import FinitePosets
+from sage.combinat.binary_tree import BinaryTrees
+from sage.combinat.binary_tree import LabelledBinaryTrees, LabelledBinaryTree
+from sage.combinat.permutation import Permutation
+from sage.misc.inherit_comparison import InheritComparisonClasscallMetaclass
+from sage.misc.cachefunc import cached_method
+from sage.misc.latex import latex
+from sage.misc.lazy_attribute import lazy_attribute
+from sage.misc.lazy_import import lazy_import
+from sage.rings.integer import Integer
+from sage.rings.integer_ring import ZZ
+from sage.rings.semirings.non_negative_integer_semiring import NN
+from sage.sets.non_negative_integers import NonNegativeIntegers
+from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
+from sage.sets.family import Family
+from sage.structure.element import Element
+from sage.structure.global_options import GlobalOptions
+from sage.structure.parent import Parent
+from sage.structure.richcmp import richcmp, op_NE, op_EQ
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.graphs.digraph import DiGraph
+
+lazy_import('sage.combinat.dyck_word', 'DyckWords')
+
+
+class TamariIntervalPoset(Element,
+                          metaclass=InheritComparisonClasscallMetaclass):
+    r"""
+    The class of Tamari interval-posets.
+
+    An interval-poset is a labelled poset of size `n`, with labels
+    `1, 2, \ldots, n`, satisfying the following conditions:
+
+    - if `a < c` (as integers) and `a` precedes `c` in the poset, then,
+      for all `b` such that `a < b < c`, `b` precedes `c`,
+
+    - if `a < c` (as integers) and `c` precedes `a` in the poset, then,
+      for all `b` such that `a < b < c`, `b` precedes `a`.
+
+    We use the word "precedes" here to distinguish the poset order and
+    the natural order on numbers. "Precedes" means "is smaller than
+    with respect to the poset structure"; this does not imply a
+    covering relation.
+
+    Interval-posets of size `n` are in bijection with intervals of
+    the Tamari lattice of binary trees of size `n`. Specifically, if
+    `P` is an interval-poset of size `n`, then the set of linear
+    extensions of `P` (as permutations in `S_n`) is an interval in the
+    right weak order (see
+    :meth:`~sage.combinat.permutation.Permutation.permutohedron_lequal`),
+    and is in fact the preimage of an interval in the Tamari lattice (of
+    binary trees of size `n`) under the operation which sends a
+    permutation to its right-to-left binary search tree
+    (:meth:`~sage.combinat.permutation.Permutation.binary_search_tree`
+    with the ``left_to_right`` variable set to ``False``)
+    without its labelling.
+
+    INPUT:
+
+    - ``size`` -- integer; the size of the interval-posets (number of
+      vertices)
+
+    - ``relations`` -- list (or tuple) of pairs ``(a,b)`` (themselves
+      lists or tuples), each representing a relation of the form
+      '`a` precedes `b`' in the poset
+
+    - ``check`` -- boolean (default: ``True``); whether to check the
+      interval-poset condition or not
+
+    .. WARNING::
+
+        The ``relations`` input can be a list or tuple, but not an
+        iterator (nor should its entries be iterators).
+
+    NOTATION:
+
+    Here and in the following, the signs `<` and `>` always refer to
+    the natural ordering on integers, whereas the word "precedes" refers
+    to the order of the interval-poset. "Minimal" and "maximal" refer
+    to the natural ordering on integers.
+
+    The *increasing relations* of an interval-poset `P` mean the pairs
+    `(a, b)` of elements of `P` such that `a < b` as integers and `a`
+    precedes `b` in `P`. The *initial forest* of `P` is the poset
+    obtained by imposing (only) the increasing relations on the ground
+    set of `P`. It is a sub-interval poset of `P`, and is a forest with
+    its roots on top. This forest is usually given the structure of a
+    planar forest by ordering brother nodes by their labels; it then has
+    the property that if its nodes are traversed in post-order
+    (see :meth:`~sage.combinat.abstract_tree.AbstractTree.post_order_traversal`,
+    and traverse the trees of the forest from left to right as well),
+    then the labels encountered are `1, 2, \ldots, n` in this order.
+
+    The *decreasing relations* of an interval-poset `P` mean the pairs
+    `(a, b)` of elements of `P` such that `b < a` as integers and `a`
+    precedes `b` in `P`. The *final forest* of `P` is the poset
+    obtained by imposing (only) the decreasing relations on the ground
+    set of `P`. It is a sub-interval poset of `P`, and is a forest with
+    its roots on top. This forest is usually given the structure of a
+    planar forest by ordering brother nodes by their labels; it then has
+    the property that if its nodes are traversed in pre-order
+    (see :meth:`~sage.combinat.abstract_tree.AbstractTree.pre_order_traversal`,
+    and traverse the trees of the forest from left to right as well),
+    then the labels encountered are `1, 2, \ldots, n` in this order.
+
+    EXAMPLES::
+
+        sage: TamariIntervalPoset(0,[])
+        The Tamari interval of size 0 induced by relations []
+        sage: TamariIntervalPoset(3,[])
+        The Tamari interval of size 3 induced by relations []
+        sage: TamariIntervalPoset(3,[(1,2)])
+        The Tamari interval of size 3 induced by relations [(1, 2)]
+        sage: TamariIntervalPoset(3,[(1,2),(2,3)])
+        The Tamari interval of size 3 induced by relations [(1, 2), (2, 3)]
+        sage: TamariIntervalPoset(3,[(1,2),(2,3),(1,3)])
+        The Tamari interval of size 3 induced by relations [(1, 2), (2, 3)]
+        sage: TamariIntervalPoset(3,[(1,2),(3,2)])
+        The Tamari interval of size 3 induced by relations [(1, 2), (3, 2)]
+        sage: TamariIntervalPoset(3,[[1,2],[2,3]])
+        The Tamari interval of size 3 induced by relations [(1, 2), (2, 3)]
+        sage: TamariIntervalPoset(3,[[1,2],[2,3],[1,2],[1,3]])
+        The Tamari interval of size 3 induced by relations [(1, 2), (2, 3)]
+
+        sage: TamariIntervalPoset(3,[(3,4)])
+        Traceback (most recent call last):
+        ...
+        ValueError: the relations do not correspond to the size of the poset
+
+        sage: TamariIntervalPoset(2,[(2,1),(1,2)])
+        Traceback (most recent call last):
+        ...
+        ValueError: The graph is not directed acyclic
+
+        sage: TamariIntervalPoset(3,[(1,3)])
+        Traceback (most recent call last):
+        ...
+        ValueError: this does not satisfy the Tamari interval-poset condition
+
+    It is also possible to transform a poset directly into an interval-poset::
+
+        sage: TIP = TamariIntervalPosets()
+        sage: p = Poset(([1,2,3], [(1,2)]))
+        sage: TIP(p)
+        The Tamari interval of size 3 induced by relations [(1, 2)]
+        sage: TIP(Poset({1: []}))
+        The Tamari interval of size 1 induced by relations []
+        sage: TIP(Poset({}))
+        The Tamari interval of size 0 induced by relations []
+    """
+    @staticmethod
+    def __classcall_private__(cls, *args, **opts) -> TIP:
+        r"""
+        Ensure that interval-posets created by the enumerated sets and
+        directly are the same and that they are instances of
+        :class:`TamariIntervalPoset`.
+
+        TESTS::
+
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: ip.parent()
+            Interval-posets
+            sage: type(ip)
+            <class 'sage.combinat.interval_posets.TamariIntervalPosets_all_with_category.element_class'>
+
+            sage: ip2 = TamariIntervalPosets()(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: ip2.parent() is ip.parent()
+            True
+            sage: type(ip) is type(ip2)
+            True
+
+            sage: ip3 = TamariIntervalPosets(4)([(2,4),(3,4),(2,1),(3,1)])
+            sage: ip3.parent() is ip.parent()
+            False
+            sage: type(ip3) is type(ip)
+            True
+        """
+        P = TamariIntervalPosets_all()
+        return P.element_class(P, *args, **opts)
+
+    def __init__(self, parent, size, relations=None, check=True):
+        r"""
+        TESTS::
+
+            sage: TamariIntervalPoset(3,[(1,2),(3,2)]).parent()
+            Interval-posets
+            sage: P = Poset(DiGraph([(4,1),(3,1),(2,1)]))
+            sage: TamariIntervalPoset(P).parent()
+            Interval-posets
+        """
+        if relations is None:
+            relations = []
+        if isinstance(size, FinitePoset):
+            # first argument is a poset
+            self._poset = size
+            self._size = size.cardinality()
+        else:
+            # arguments are size and relations
+            self._size = size
+            self._poset = Poset((list(range(1, size + 1)), relations))
+            if self._poset.cardinality() != size:
+                # This can happen as the Poset constructor automatically adds
+                # in elements from the relations.
+                raise ValueError("the relations do not correspond to the size of the poset")
+
+        if check and not TamariIntervalPosets.check_poset(self._poset):
+            raise ValueError("this does not satisfy the Tamari interval-poset condition")
+
+        Element.__init__(self, parent)
+
+        self._cover_relations = tuple(self._poset.cover_relations())
+        self._latex_options = {}
+
+    def set_latex_options(self, D):
+        r"""
+        Set the latex options for use in the ``_latex_`` function.
+
+        The default values are set in the ``__init__`` function.
+
+        - ``tikz_scale`` -- (default: 1) scale for use with the tikz package
+
+        - ``line_width`` -- (default: 1 * ``tikz_scale``) value representing the
+          line width
+
+        - ``color_decreasing`` -- (default: red) the color for decreasing
+          relations
+
+        - ``color_increasing`` -- (default: blue) the color for increasing
+          relations
+
+        - ``hspace`` -- (default: 1) the difference between horizontal
+          coordinates of adjacent vertices
+
+        - ``vspace`` -- (default: 1) the difference between vertical
+          coordinates of adjacent vertices
+
+        INPUT:
+
+        - ``D`` -- dictionary with a list of latex parameters to change
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: ip.latex_options()["color_decreasing"]
+            'red'
+            sage: ip.set_latex_options({"color_decreasing":'green'})
+            sage: ip.latex_options()["color_decreasing"]
+            'green'
+            sage: ip.set_latex_options({"color_increasing":'black'})
+            sage: ip.latex_options()["color_increasing"]
+            'black'
+
+        To change the default options for all interval-posets, use the
+        parent's latex options::
+
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: ip2 = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip.latex_options()["color_decreasing"]
+            'red'
+            sage: ip2.latex_options()["color_decreasing"]
+            'red'
+            sage: TamariIntervalPosets.options(latex_color_decreasing='green')
+            sage: ip.latex_options()["color_decreasing"]
+            'green'
+            sage: ip2.latex_options()["color_decreasing"]
+            'green'
+
+        Next we set a local latex option and show the global option does not
+        override it::
+
+            sage: ip.set_latex_options({"color_decreasing": 'black'})
+            sage: ip.latex_options()["color_decreasing"]
+            'black'
+            sage: TamariIntervalPosets.options(latex_color_decreasing='blue')
+            sage: ip.latex_options()["color_decreasing"]
+            'black'
+            sage: ip2.latex_options()["color_decreasing"]
+            'blue'
+            sage: TamariIntervalPosets.options._reset()
+        """
+        for opt in D:
+            self._latex_options[opt] = D[opt]
+
+    def latex_options(self) -> dict:
+        r"""
+        Return the latex options for use in the ``_latex_`` function as a
+        dictionary.
+
+        The default values are set using the options.
+
+        - ``tikz_scale`` -- (default: 1) scale for use with the tikz package
+
+        - ``line_width`` -- (default: 1) value representing the line width
+          (additionally scaled by ``tikz_scale``)
+
+        - ``color_decreasing`` -- (default: ``'red'``) the color for
+          decreasing relations
+
+        - ``color_increasing`` -- (default: ``'blue'``) the color for
+          increasing relations
+
+        - ``hspace`` -- (default: 1) the difference between horizontal
+          coordinates of adjacent vertices
+
+        - ``vspace`` -- (default: 1) the difference between vertical
+          coordinates of adjacent vertices
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: ip.latex_options()['color_decreasing']
+            'red'
+            sage: ip.latex_options()['hspace']
+            1
+        """
+        d = self._latex_options.copy()
+        if "tikz_scale" not in d:
+            d["tikz_scale"] = self.parent().options["latex_tikz_scale"]
+        if "line_width" not in d:
+            d["line_width"] = self.parent().options["latex_line_width_scalar"] * d["tikz_scale"]
+        if "color_decreasing" not in d:
+            d["color_decreasing"] = self.parent().options["latex_color_decreasing"]
+        if "color_increasing" not in d:
+            d["color_increasing"] = self.parent().options["latex_color_increasing"]
+        if "hspace" not in d:
+            d["hspace"] = self.parent().options["latex_hspace"]
+        if "vspace" not in d:
+            d["vspace"] = self.parent().options["latex_vspace"]
+        return d
+
+    def _find_node_positions(self, hspace=1, vspace=1) -> dict[int, list]:
+        """
+        Compute a nice embedding.
+
+        If `x` precedes `y`, then `y` will always be placed on top of `x`
+        and/or to the right of `x`.
+        Decreasing relations tend to be drawn vertically and increasing
+        relations horizontally.
+        The algorithm tries to avoid superposition but on big
+        interval-posets, it might happen.
+
+        OUTPUT:
+
+        a dictionary {vertex: (x,y)}
+
+        EXAMPLES::
+
+            sage: ti = TamariIntervalPosets(4)[2]
+            sage: list(ti._find_node_positions().values())
+            [[0, 0], [0, -1], [0, -2], [1, -2]]
+        """
+        node_positions = {}
+
+        to_draw = [(1, 0)]
+        current_parent = [self.increasing_parent(1)]
+        parenty = [0]
+        x = 0
+        y = 0
+        for i in range(2, self.size() + 1):
+            decreasing_parent = self.decreasing_parent(i)
+            increasing_parent = self.increasing_parent(i)
+            while to_draw and (decreasing_parent is None or
+                               decreasing_parent < to_draw[-1][0]):
+                n = to_draw.pop()
+                node_positions[n[0]] = [x, n[1]]
+            if i != current_parent[-1]:
+                if (not self.le(i, i - 1) and decreasing_parent is not None):
+                    x += hspace
+                    if current_parent[-1] is not None:
+                        y -= vspace
+                else:
+                    y -= vspace
+                if increasing_parent != current_parent[-1]:
+                    current_parent.append(increasing_parent)
+                    parenty.append(y)
+                nodey = y
+            else:
+                current_parent.pop()
+                x += hspace
+                nodey = parenty.pop()
+                if not current_parent or increasing_parent != current_parent[-1]:
+                    current_parent.append(increasing_parent)
+                    parenty.append(nodey)
+            to_draw.append((i, nodey))
+
+        for n in to_draw:
+            node_positions[n[0]] = [x, n[1]]
+        return node_positions
+
+    def plot(self, **kwds):
+        """
+        Return a picture.
+
+        The picture represents the Hasse diagram, where the covers are
+        colored in blue if they are increasing and in red if they are
+        decreasing.
+
+        This uses the same coordinates as the latex view.
+
+        EXAMPLES::
+
+            sage: ti = TamariIntervalPosets(4)[2]
+            sage: ti.plot()                                                             # needs sage.plot
+            Graphics object consisting of 6 graphics primitives
+
+        TESTS::
+
+            sage: ti = TamariIntervalPoset(3, [[2,1], [2,3]])
+            sage: ti.plot()                                                             # needs sage.plot
+            Graphics object consisting of 6 graphics primitives
+        """
+        c0 = 'blue'   # self.latex_options()["color_increasing"]
+        c1 = 'red'    # self.latex_options()["color_decreasing"]
+        G = self.poset().hasse_diagram()
+        G.set_pos(self._find_node_positions())
+        for a, b in G.edges(sort=False, labels=False):
+            if a < b:
+                G.set_edge_label(a, b, 0)
+            else:
+                G.set_edge_label(a, b, 1)
+        return G.plot(color_by_label={0: c0, 1: c1}, **kwds)
+
+    def _latex_(self) -> str:
+        r"""
+        A latex representation of ``self`` using the tikzpicture package.
+
+        This picture shows the union of the Hasse diagrams of the
+        initial and final forests.
+
+        If `x` precedes `y`, then `y` will always be placed on top of `x`
+        and/or to the right of `x`.
+        Decreasing relations tend to be drawn vertically and increasing
+        relations horizontally.
+        The algorithm tries to avoid superposition but on big
+        interval-posets, it might happen.
+
+        You can use ``self.set_latex_options()`` to change default latex
+        options. Or you can use the parent's options.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: latex(ip)
+            \begin{tikzpicture}[scale=1]
+            \node(T1) at (1,0) {1};
+            \node(T2) at (0,-1) {2};
+            \node(T3) at (1,-2) {3};
+            \node(T4) at (2,-1) {4};
+            \draw[line width = 0.5, color=red] (T3) -- (T1);
+            \draw[line width = 0.5, color=red] (T2) -- (T1);
+            \draw[line width = 0.5, color=blue] (T2) -- (T4);
+            \draw[line width = 0.5, color=blue] (T3) -- (T4);
+            \end{tikzpicture}
+
+        TESTS::
+
+            sage: ip = TamariIntervalPoset(0,[])
+            sage: latex(ip)
+            \begin{tikzpicture}[scale=1]
+            \node(T0) at (0,0){$\emptyset$};\end{tikzpicture}
+        """
+        latex.add_package_to_preamble_if_available("tikz")
+        latex_options = self.latex_options()
+        start = "\\begin{tikzpicture}[scale=" + str(latex_options['tikz_scale']) + "]\n"
+        end = "\\end{tikzpicture}"
+        vspace = latex_options["vspace"]
+        hspace = latex_options["hspace"]
+
+        def draw_node(j, x, y) -> str:
+            r"""
+            Internal method to draw vertices
+            """
+            return "\\node(T" + str(j) + ") at (" + str(x) + "," + str(y) + ") {" + str(j) + "};\n"
+
+        def draw_increasing(i, j) -> str:
+            r"""
+            Internal method to draw increasing relations
+            """
+            return "\\draw[line width = " + str(latex_options["line_width"]) + ", color=" + latex_options["color_increasing"] + "] (T" + str(i) + ") -- (T" + str(j) + ");\n"
+
+        def draw_decreasing(i, j) -> str:
+            r"""
+            Internal method to draw decreasing relations
+            """
+            return "\\draw[line width = " + str(latex_options["line_width"]) + ", color=" + latex_options["color_decreasing"] + "] (T" + str(i) + ") -- (T" + str(j) + ");\n"
+
+        if self.size() == 0:
+            nodes = "\\node(T0) at (0,0){$\\emptyset$};"
+            relations = ""
+        else:
+            positions = self._find_node_positions(hspace, vspace)
+            nodes = ""  # latex for node declarations
+            relations = ""  # latex for drawing relations
+            for i in range(1, self.size() + 1):
+                nodes += draw_node(i, *positions[i])
+            for i, j in self.decreasing_cover_relations():
+                relations += draw_decreasing(i, j)
+            for i, j in self.increasing_cover_relations():
+                relations += draw_increasing(i, j)
+
+        return start + nodes + relations + end
+
+    def poset(self) -> FinitePoset:
+        r"""
+        Return ``self`` as a labelled poset.
+
+        An interval-poset is indeed constructed from a labelled poset which
+        is stored internally. This method allows to access the poset and
+        all the associated methods.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(3,2),(2,4),(3,4)])
+            sage: pos = ip.poset(); pos
+            Finite poset containing 4 elements
+            sage: pos.maximal_chains()
+            [[3, 2, 4], [1, 2, 4]]
+            sage: pos.maximal_elements()
+            [4]
+            sage: pos.is_lattice()
+            False
+        """
+        return self._poset
+
+    def _mul_(self, other: TIP) -> TIP:
+        """
+        Return the associative product of ``self`` and ``other``.
+
+        This is defined by taking the disjoint union of the relations
+        of ``self`` with the relations of ``other`` shifted by `n`,
+        where `n` is the size of ``self``.
+
+        EXAMPLES::
+
+            sage: T1 = TamariIntervalPoset(1,[])
+            sage: T2 = TamariIntervalPoset(2,[[1,2]])
+            sage: T1*T1
+            The Tamari interval of size 2 induced by relations []
+            sage: T2*T1
+            The Tamari interval of size 3 induced by relations [(1, 2)]
+            sage: T1*T2
+            The Tamari interval of size 3 induced by relations [(2, 3)]
+            sage: T2*T2
+            The Tamari interval of size 4 induced by relations [(1, 2), (3, 4)]
+
+        TESTS::
+
+            sage: U = TamariIntervalPoset(0,[])
+            sage: U*T1 == T1
+            True
+            sage: T2*U == T2
+            True
+        """
+        n = self._size
+        m = other.size()
+        relations = self._poset.cover_relations()
+        relations.extend((i + n, j + n)
+                         for i, j in other._poset.cover_relations_iterator())
+        P = FinitePoset(DiGraph([list(range(1, n + m + 1)), relations],
+                                format='vertices_and_edges'))  # type:ignore
+        return TamariIntervalPoset(P, check=False)  # type:ignore
+
+    def factor(self) -> list[TamariIntervalPoset]:
+        """
+        Return the unique decomposition as a list of connected components.
+
+        EXAMPLES::
+
+            sage: factor(TamariIntervalPoset(2,[]))  # indirect doctest
+            [The Tamari interval of size 1 induced by relations [],
+             The Tamari interval of size 1 induced by relations []]
+
+        .. SEEALSO:: :meth:`is_connected`
+
+        TESTS::
+
+            sage: # needs sage.combinat
+            sage: T = TamariIntervalPosets(20).random_element()
+            sage: facs = factor(T)
+            sage: all(U.is_connected() for U in facs)
+            True
+            sage: T == prod(facs)
+            True
+        """
+        hasse = self.poset().hasse_diagram()
+        cc = hasse.connected_components_subgraphs()
+        resu = []
+        for comp in sorted(cc, key=min):
+            shift = 1 - min(comp)
+            comp.relabel(lambda i: i + shift)
+            resu.append(TamariIntervalPoset(len(comp),
+                                            comp.edges(sort=False, labels=False)))
+        return resu
+
+    def __hash__(self):
+        """
+        Return the hash of ``self``.
+
+        EXAMPLES::
+
+            sage: len(set(hash(u) for u in TamariIntervalPosets(4)))
+            68
+        """
+        pair = (self.size(), tuple(tuple(e) for e in self._cover_relations))
+        return hash(pair)
+
+    @cached_method
+    def increasing_cover_relations(self) -> list[tuple[int, int]]:
+        r"""
+        Return the cover relations of the initial forest of ``self``.
+
+        This is the poset formed by keeping only the relations of the form
+        `a` precedes `b` with `a < b`.
+
+        The initial forest of ``self`` is a forest with its roots
+        being on top. It is also called the increasing poset of ``self``.
+
+        .. WARNING::
+
+            This method computes the cover relations of the initial
+            forest. This is not identical with the cover relations of
+            ``self`` which happen to be increasing!
+
+        .. SEEALSO::
+
+            :meth:`initial_forest`
+
+        EXAMPLES::
+
+            sage: TamariIntervalPoset(4,[(1,2),(3,2),(2,4),(3,4)]).increasing_cover_relations()
+            [(1, 2), (2, 4), (3, 4)]
+            sage: TamariIntervalPoset(3,[(1,2),(1,3),(2,3)]).increasing_cover_relations()
+            [(1, 2), (2, 3)]
+        """
+        relations = []
+        size = self.size()
+        for i in range(1, size):
+            for j in range(i + 1, size + 1):
+                if self.le(i, j):
+                    relations.append((i, j))
+                    break
+        return relations
+
+    def increasing_roots(self) -> list[int]:
+        r"""
+        Return the root vertices of the initial forest of ``self``.
+
+        These are the vertices `a` of ``self`` such that there is no
+        `b > a` with `a` precedes `b`.
+
+        OUTPUT:
+
+        The list of all roots of the initial forest of ``self``, in
+        decreasing order.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(3,5),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations [(1, 2), (3, 5), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.increasing_roots()
+            [6, 5, 2]
+            sage: ip.initial_forest().increasing_roots()
+            [6, 5, 2]
+
+        TESTS::
+
+            sage: TamariIntervalPoset(0,[]).increasing_roots()
+            []
+        """
+        size = self.size()
+        if size == 0:
+            return []
+        roots = [size]
+        root = size
+        for i in range(size - 1, 0, -1):
+            if not self.le(i, root):
+                roots.append(i)
+                root = i
+        return roots
+
+    def increasing_children(self, v) -> list[int]:
+        r"""
+        Return the children of ``v`` in the initial forest of ``self``.
+
+        INPUT:
+
+        - ``v`` -- integer representing a vertex of ``self``
+          (between 1 and ``size``)
+
+        OUTPUT:
+
+        The list of all children of ``v`` in the initial forest of
+        ``self``, in decreasing order.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(3,5),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations [(1, 2), (3, 5), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.increasing_children(2)
+            [1]
+            sage: ip.increasing_children(5)
+            [4, 3]
+            sage: ip.increasing_children(1)
+            []
+        """
+        children = []
+        root = None
+        for i in range(v - 1, 0, -1):
+            if not self.le(i, v):
+                break
+            if root is None or not self.le(i, root):
+                children.append(i)
+                root = i
+        return children
+
+    def increasing_parent(self, v) -> None | int:
+        r"""
+        Return the vertex parent of ``v`` in the initial forest of ``self``.
+
+        This is the lowest (as integer!) vertex `b > v` such that `v`
+        precedes `b`. If there is no such vertex (that is, `v` is an
+        increasing root), then ``None`` is returned.
+
+        INPUT:
+
+        - ``v`` -- integer representing a vertex of ``self``
+          (between 1 and ``size``)
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(3,5),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations [(1, 2), (3, 5), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.increasing_parent(1)
+            2
+            sage: ip.increasing_parent(3)
+            5
+            sage: ip.increasing_parent(4)
+            5
+            sage: ip.increasing_parent(5) is None
+            True
+        """
+        parent = None
+        for i in range(self.size(), v, -1):
+            if self.le(v, i):
+                parent = i
+        return parent
+
+    @cached_method
+    def decreasing_cover_relations(self) -> list[tuple[int, int]]:
+        r"""
+        Return the cover relations of the final forest of ``self``.
+
+        This is the poset formed by keeping only the relations of the form
+        `a` precedes `b` with `a > b`.
+
+        The final forest of ``self`` is a forest with its roots
+        being on top. It is also called the decreasing poset of ``self``.
+
+        .. WARNING::
+
+            This method computes the cover relations of the final
+            forest. This is not identical with the cover relations of
+            ``self`` which happen to be decreasing!
+
+        .. SEEALSO::
+
+            :meth:`final_forest`
+
+        EXAMPLES::
+
+            sage: TamariIntervalPoset(4,[(2,1),(3,2),(3,4),(4,2)]).decreasing_cover_relations()
+            [(4, 2), (3, 2), (2, 1)]
+            sage: TamariIntervalPoset(4,[(2,1),(4,3),(2,3)]).decreasing_cover_relations()
+            [(4, 3), (2, 1)]
+            sage: TamariIntervalPoset(3,[(2,1),(3,1),(3,2)]).decreasing_cover_relations()
+            [(3, 2), (2, 1)]
+        """
+        relations = []
+        for i in range(self.size(), 1, -1):
+            for j in range(i - 1, 0, -1):
+                if self.le(i, j):
+                    relations.append((i, j))
+                    break
+        return relations
+
+    def decreasing_roots(self) -> list[int]:
+        r"""
+        Return the root vertices of the final forest of ``self``.
+
+        These are the vertices `b` such that there is no `a < b` with `b`
+        preceding `a`.
+
+        OUTPUT:
+
+        The list of all roots of the final forest of ``self``, in
+        increasing order.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(3,5),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations [(1, 2), (3, 5), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.decreasing_roots()
+            [1, 2]
+            sage: ip.final_forest().decreasing_roots()
+            [1, 2]
+        """
+        if self.size() == 0:
+            return []
+        roots = [1]
+        root = 1
+        for i in range(2, self.size() + 1):
+            if not self.le(i, root):
+                roots.append(i)
+                root = i
+        return roots
+
+    def decreasing_children(self, v) -> list[int]:
+        r"""
+        Return the children of ``v`` in the final forest of ``self``.
+
+        INPUT:
+
+        - ``v`` -- integer representing a vertex of ``self``
+          (between 1 and ``size``)
+
+        OUTPUT:
+
+        The list of all children of ``v`` in the final forest of ``self``,
+        in increasing order.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(3,5),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations [(1, 2), (3, 5), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.decreasing_children(2)
+            [3, 5]
+            sage: ip.decreasing_children(3)
+            [4]
+            sage: ip.decreasing_children(1)
+            []
+        """
+        children = []
+        root = None
+        for i in range(v + 1, self.size() + 1):
+            if not self.le(i, v):
+                break
+            if root is None or not self.le(i, root):
+                children.append(i)
+                root = i
+        return children
+
+    def decreasing_parent(self, v) -> None | int:
+        r"""
+        Return the vertex parent of ``v`` in the final forest of ``self``.
+
+        This is the highest (as integer!) vertex `a < v` such that ``v``
+        precedes ``a``. If there is no such vertex (that is, `v` is a
+        decreasing root), then ``None`` is returned.
+
+        INPUT:
+
+        - ``v`` -- integer representing a vertex of ``self`` (between
+          1 and ``size``)
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(3,5),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations [(1, 2), (3, 5), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.decreasing_parent(4)
+            3
+            sage: ip.decreasing_parent(3)
+            2
+            sage: ip.decreasing_parent(5)
+            2
+            sage: ip.decreasing_parent(2) is None
+            True
+        """
+        parent = None
+        for i in range(1, v):
+            if self.le(v, i):
+                parent = i
+        return parent
+
+    def le(self, e1, e2) -> bool:
+        r"""
+        Return whether ``e1`` precedes or equals ``e2`` in ``self``.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip.le(1,2)
+            True
+            sage: ip.le(1,3)
+            True
+            sage: ip.le(2,3)
+            True
+            sage: ip.le(3,4)
+            False
+            sage: ip.le(1,1)
+            True
+        """
+        return self._poset.le(e1, e2)
+
+    def lt(self, e1, e2) -> bool:
+        r"""
+        Return whether ``e1`` strictly precedes ``e2`` in ``self``.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip.lt(1,2)
+            True
+            sage: ip.lt(1,3)
+            True
+            sage: ip.lt(2,3)
+            True
+            sage: ip.lt(3,4)
+            False
+            sage: ip.lt(1,1)
+            False
+        """
+        return self._poset.lt(e1, e2)
+
+    def ge(self, e1, e2) -> bool:
+        r"""
+        Return whether ``e2`` precedes or equals ``e1`` in ``self``.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip.ge(2,1)
+            True
+            sage: ip.ge(3,1)
+            True
+            sage: ip.ge(3,2)
+            True
+            sage: ip.ge(4,3)
+            False
+            sage: ip.ge(1,1)
+            True
+        """
+        return self._poset.ge(e1, e2)
+
+    def gt(self, e1, e2) -> bool:
+        r"""
+        Return whether ``e2`` strictly precedes ``e1`` in ``self``.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip.gt(2,1)
+            True
+            sage: ip.gt(3,1)
+            True
+            sage: ip.gt(3,2)
+            True
+            sage: ip.gt(4,3)
+            False
+            sage: ip.gt(1,1)
+            False
+        """
+        return self._poset.gt(e1, e2)
+
+    def size(self) -> Integer:
+        r"""
+        Return the size (number of vertices) of the interval-poset.
+
+        EXAMPLES::
+
+            sage: TamariIntervalPoset(3,[(2,1),(3,1)]).size()
+            3
+        """
+        return self._size
+
+    @cached_method
+    def cubical_coordinates(self) -> tuple[int, ...]:
+        """
+        Return the cubical coordinates of ``self``.
+
+        This provides a fast and natural way to order
+        the set of interval-posets of a given size.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip.cubical_coordinates()
+            (-1, -2, 0)
+
+        TESTS::
+
+            sage: ip = TamariIntervalPoset(1,[])
+            sage: ip.cubical_coordinates()
+            ()
+            sage: ip = TamariIntervalPoset(3,[])
+            sage: ip.cubical_coordinates()
+            (0, 0)
+            sage: ip = TamariIntervalPosets(10).random_element()                        # needs sage.combinat
+            sage: len(ip.cubical_coordinates())                                         # needs sage.combinat
+            9
+            sage: sorted(ip.cubical_coordinates() for ip in TamariIntervalPosets(2))    # needs sage.combinat
+            [(-1,), (0,), (1,)]
+
+        REFERENCES:
+
+        - [Com2019]_
+        """
+        tup = [0] * (self.size() - 1)
+        for i, j in self._poset.relations_iterator(strict=True):
+            if i < j:
+                tup[j - 2] -= 1
+            else:
+                tup[j - 1] += 1
+        return tuple(tup)
+
+    def complement(self) -> TIP:
+        r"""
+        Return the complement of the interval-poset ``self``.
+
+        If `P` is a Tamari interval-poset of size `n`, then the
+        *complement* of `P` is defined as the interval-poset `Q` whose
+        base set is `[n] = \{1, 2, \ldots, n\}` (just as for `P`), but
+        whose order relation has `a` precede `b` if and only if
+        `n + 1 - a` precedes `n + 1 - b` in `P`.
+
+        In terms of the Tamari lattice, the *complement* is the symmetric
+        of ``self``. It is formed from the left-right symmetrized of
+        the binary trees of the interval (switching left and right
+        subtrees, see
+        :meth:`~sage.combinat.binary_tree.BinaryTree.left_right_symmetry`).
+        In particular, initial intervals are sent to final intervals and
+        vice-versa.
+
+        EXAMPLES::
+
+            sage: TamariIntervalPoset(3, [(2, 1), (3, 1)]).complement()
+            The Tamari interval of size 3 induced by relations [(1, 3), (2, 3)]
+            sage: TamariIntervalPoset(0, []).complement()
+            The Tamari interval of size 0 induced by relations []
+            sage: ip = TamariIntervalPoset(4, [(1, 2), (2, 4), (3, 4)])
+            sage: ip.complement() == TamariIntervalPoset(4, [(2, 1), (3, 1), (4, 3)])
+            True
+            sage: ip.lower_binary_tree() == ip.complement().upper_binary_tree().left_right_symmetry()
+            True
+            sage: ip.upper_binary_tree() == ip.complement().lower_binary_tree().left_right_symmetry()
+            True
+            sage: ip.is_initial_interval()
+            True
+            sage: ip.complement().is_final_interval()
+            True
+        """
+        N = self._size + 1
+        new_covers = [[N - i, N - j]
+                      for i, j in self._poset.cover_relations_iterator()]
+        P = FinitePoset(DiGraph([list(range(1, N)), new_covers],
+                                format='vertices_and_edges'))  # type:ignore
+        return TamariIntervalPoset(P, check=False)  # type:ignore
+
+    def left_branch_involution(self) -> TIP:
+        """
+        Return the image of ``self`` by the left-branch involution.
+
+        OUTPUT: an interval-poset
+
+        .. SEEALSO:: :meth:`rise_contact_involution`
+
+        EXAMPLES::
+
+            sage: tip = TamariIntervalPoset(8, [(1,2), (2,4), (3,4), (6,7), (3,2), (5,4), (6,4), (8,7)])
+            sage: t = tip.left_branch_involution(); t
+            The Tamari interval of size 8 induced by relations [(1, 6), (2, 6),
+            (3, 5), (4, 5), (5, 6), (6, 8), (7, 8), (7, 6), (4, 3), (3, 1),
+            (2, 1)]
+            sage: t.left_branch_involution() == tip
+            True
+
+        REFERENCES:
+
+        - [Pons2018]_
+        """
+        gt = self.grafting_tree().left_border_symmetry()
+        return TamariIntervalPosets.from_grafting_tree(gt)
+
+    def rise_contact_involution(self) -> TIP:
+        """
+        Return the image of ``self`` by the rise-contact involution.
+
+        OUTPUT: an interval-poset
+
+        This is defined by conjugating the complement involution
+        by the left-branch involution.
+
+        .. SEEALSO:: :meth:`left_branch_involution`, :meth:`complement`
+
+        EXAMPLES::
+
+            sage: tip = TamariIntervalPoset(8, [(1,2), (2,4), (3,4), (6,7),
+            ....:                               (3,2), (5,4), (6,4), (8,7)])
+            sage: t = tip.rise_contact_involution(); t
+            The Tamari interval of size 8 induced by relations [(2, 8), (3, 8),
+            (4, 5), (5, 7), (6, 7), (7, 8), (8, 1), (7, 2), (6, 2), (5, 3),
+            (4, 3), (3, 2), (2, 1)]
+            sage: t.rise_contact_involution() == tip
+            True
+            sage: (tip.lower_dyck_word().number_of_touch_points()                       # needs sage.combinat
+            ....:     == t.upper_dyck_word().number_of_initial_rises())
+            True
+            sage: tip.number_of_tamari_inversions() == t.number_of_tamari_inversions()
+            True
+
+        REFERENCES:
+
+        - [Pons2018]_
+        """
+        t = self.left_branch_involution().complement()
+        return t.left_branch_involution()
+
+    def insertion(self, i) -> TIP:
+        r"""
+        Return the Tamari insertion of an integer `i` into the
+        interval-poset ``self``.
+
+        If `P` is a Tamari interval-poset of size `n` and `i` is an
+        integer with `1 \leq i \leq n+1`, then the Tamari insertion of
+        `i` into `P` is defined as the Tamari interval-poset of size
+        `n+1` which corresponds to the interval `[C_1, C_2]` on the
+        Tamari lattice, where the binary trees `C_1` and `C_2` are
+        defined as follows: We write the interval-poset `P` as
+        `[B_1, B_2]` for two binary trees `B_1` and `B_2`. We label
+        the vertices of each of these two trees with the integers
+        `1, 2, \ldots, i-1, i+1, i+2, \ldots, n+1` in such a way that
+        the trees are binary search trees (this labelling is unique).
+        Then, we insert `i` into each of these trees (in the way as
+        explained in
+        :meth:`~sage.combinat.binary_tree.LabelledBinaryTree.binary_search_insert`).
+        The shapes of the resulting two trees are denoted `C_1` and
+        `C_2`.
+
+        An alternative way to construct the insertion of `i` into
+        `P` is by relabeling each vertex `u` of `P` satisfying
+        `u \geq i` (as integers) as `u+1`, and then adding a vertex
+        `i` which should precede `i-1` and `i+1`.
+
+        .. TODO::
+
+            To study this, it would be more natural to define
+            interval-posets on arbitrary ordered sets rather than just
+            on `\{1, 2, \ldots, n\}`.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4, [(2, 3), (4, 3)]); ip
+            The Tamari interval of size 4 induced by relations [(2, 3), (4, 3)]
+            sage: ip.insertion(1)
+            The Tamari interval of size 5 induced by relations [(1, 2), (3, 4), (5, 4)]
+            sage: ip.insertion(2)
+            The Tamari interval of size 5 induced by relations [(2, 3), (3, 4), (5, 4), (2, 1)]
+            sage: ip.insertion(3)
+            The Tamari interval of size 5 induced by relations [(2, 4), (3, 4), (5, 4), (3, 2)]
+            sage: ip.insertion(4)
+            The Tamari interval of size 5 induced by relations [(2, 3), (4, 5), (5, 3), (4, 3)]
+            sage: ip.insertion(5)
+            The Tamari interval of size 5 induced by relations [(2, 3), (5, 4), (4, 3)]
+
+            sage: ip = TamariIntervalPoset(0, [])
+            sage: ip.insertion(1)
+            The Tamari interval of size 1 induced by relations []
+
+            sage: ip = TamariIntervalPoset(1, [])
+            sage: ip.insertion(1)
+            The Tamari interval of size 2 induced by relations [(1, 2)]
+            sage: ip.insertion(2)
+            The Tamari interval of size 2 induced by relations [(2, 1)]
+
+        TESTS:
+
+        Verifying that the two ways of computing insertion are
+        equivalent::
+
+            sage: def insert_alternative(T, i):
+            ....:     # Just another way to compute the insertion of i into T.
+            ....:     from sage.combinat.binary_tree import LabelledBinaryTree
+            ....:     B1 = T.lower_binary_tree().canonical_labelling()
+            ....:     B2 = T.upper_binary_tree().canonical_labelling()
+            ....:     C1 = B1.binary_search_insert(i)
+            ....:     C2 = B2.binary_search_insert(i)
+            ....:     return TamariIntervalPosets.from_binary_trees(C1, C2)
+
+        We should have relabelled the trees to "make space" for a label i,
+        but we did not, because it does not make a difference: The
+        binary search insertion will go precisely the same, because
+        an integer equal to the label of the root gets sent onto
+        the left branch.
+
+            sage: def test_equivalence(n):
+            ....:     for T in TamariIntervalPosets(n):
+            ....:         for i in range(1, n + 2):
+            ....:             if insert_alternative(T, i) != T.insertion(i):
+            ....:                 print(T, i)
+            ....:                 return False
+            ....:     return True
+            sage: test_equivalence(3)                                                   # needs sage.combinat
+            True
+
+            sage: ti = TamariIntervalPosets(3).an_element()
+            sage: ti.insertion(6)
+            Traceback (most recent call last):
+            ...
+            ValueError: integer to be inserted not in the appropriate interval
+        """
+        n = self._size
+        if not 0 < i <= n + 1:
+            raise ValueError("integer to be inserted not "
+                             "in the appropriate interval")
+
+        def add1(u):
+            if u >= i:
+                return u + 1
+            return u
+        rels = [(add1(a), add1(b))
+                for (a, b) in self.decreasing_cover_relations()]
+        rels += [(add1(a), add1(b))
+                 for (a, b) in self.increasing_cover_relations()]
+        rels += [(k, k - 1) for k in [i] if i > 1]
+        rels += [(k, k + 1) for k in [i] if i <= n]
+        return TamariIntervalPoset(n + 1, rels)
+
+    def _repr_(self) -> str:
+        r"""
+        Return a string representation of ``self``.
+
+        TESTS::
+
+            sage: TamariIntervalPoset(3,[(2,1),(3,1)])
+            The Tamari interval of size 3 induced by relations [(3, 1), (2, 1)]
+            sage: TamariIntervalPoset(3,[(3,1),(2,1)])
+            The Tamari interval of size 3 induced by relations [(3, 1), (2, 1)]
+            sage: TamariIntervalPoset(3,[(2,3),(2,1)])
+            The Tamari interval of size 3 induced by relations [(2, 3), (2, 1)]
+        """
+        msg = "The Tamari interval of size {} induced by relations {}"
+        return msg.format(self.size(),
+                          self.increasing_cover_relations() +
+                          self.decreasing_cover_relations())
+
+    def _ascii_art_(self):
+        """
+        Return an ascii art picture of ``self``.
+
+        This is a picture of the Hasse diagram. Vertices from `1` to `n`
+        are placed on the diagonal from top-left to bottom-right.
+        Then increasing covers are drawn above the diagonal
+        and decreasing covers are drawn below the diagonal.
+
+        EXAMPLES::
+
+            sage: T = TamariIntervalPosets(5)[56]
+            sage: ascii_art(T)
+             O-----------+
+                O--------+
+                +--O--+  |
+                      O--+
+                         O
+            sage: T.poset().cover_relations()
+            [[3, 4], [3, 2], [4, 5], [2, 5], [1, 5]]
+        """
+        n = self.size()
+        M = [[' O ' if i == j else '   ' for i in range(n)] for j in range(n)]
+
+        def superpose(x, y, b):
+            # put symbol b at position x, y
+            # on top of existing symbols there
+            i = x - 1
+            j = y - 1
+            a = M[i][j]
+            if a == '   ':
+                M[i][j] = b
+            elif a == '-+ ':
+                if b == a:
+                    pass
+                elif b == '---':
+                    M[i][j] = '-+-'
+                elif b == ' | ':
+                    M[i][j] = '-+ '
+            elif a == ' +-':
+                if b == a:
+                    pass
+                elif b == '---':
+                    M[i][j] = '-+-'
+                elif b == ' | ':
+                    M[i][j] = ' +-'
+            elif a == '---':
+                if b == a:
+                    pass
+                elif b == '-+ ':
+                    M[i][j] = '-+-'
+                elif b == ' +-':
+                    M[i][j] = '-+-'
+            elif a == ' | ':
+                if b == a:
+                    pass
+                elif b == '-+ ':
+                    M[i][j] = '-+ '
+                elif b == ' +-':
+                    M[i][j] = ' +-'
+
+        def superpose_node(i, right=True):
+            i -= 1  # for indexing
+            if M[i][i] == ' O ':
+                if right:
+                    M[i][i] = ' O-'
+                else:
+                    M[i][i] = '-O '
+            elif M[i][i] == ' O-' and not right:
+                M[i][i] = '-O-'
+            elif M[i][i] == '-O ' and right:
+                M[i][i] = '-O-'
+
+        for i, j in self.poset().hasse_diagram().edges(sort=True, labels=False):
+            if i > j:
+                superpose_node(i, False)
+                superpose(i, j, ' +-')
+                for k in range(j + 1, i):
+                    superpose(k, j, ' | ')
+                    superpose(i, k, '---')
+            else:
+                superpose_node(i, True)
+                superpose(i, j, '-+ ')
+                for k in range(i + 1, j):
+                    superpose(i, k, '---')
+                    superpose(k, j, ' | ')
+
+        from sage.typeset.ascii_art import AsciiArt
+        return AsciiArt([''.join(ligne) for ligne in M])
+
+    def _unicode_art_(self):
+        """
+        Return an unicode picture of ``self``.
+
+        This is a picture of the Hasse diagram. Vertices from `1` to `n` are
+        placed on the diagonal from top-left to bottom-right.
+        Then increasing covers are drawn above the diagonal
+        and decreasing covers are drawn below the diagonal.
+
+        EXAMPLES::
+
+            sage: T = TamariIntervalPosets(5)[56]
+            sage: unicode_art(T)
+            o───╮
+             o──┤
+             ╰o╮│
+               o┤
+                o
+            sage: T.poset().cover_relations()
+            [[3, 4], [3, 2], [4, 5], [2, 5], [1, 5]]
+        """
+        n = self.size()
+        M = [['o' if i == j else ' ' for i in range(n)] for j in range(n)]
+
+        def superpose(x, y, b):
+            # put symbol b at position x, y
+            # on top of existing symbols there
+            i = x - 1
+            j = y - 1
+            a = M[i][j]
+            if a == ' ':
+                M[i][j] = b
+            elif a == '╮':
+                if b == a:
+                    pass
+                elif b == '─':
+                    M[i][j] = '┬'
+                elif b == '│':
+                    M[i][j] = '┤'
+            elif a == '╰':
+                if b == a:
+                    pass
+                elif b == '─':
+                    M[i][j] = '┴'
+                elif b == '│':
+                    M[i][j] = '├'
+            elif a == '─':
+                if b == a:
+                    pass
+                elif b == '╮':
+                    M[i][j] = '┬'
+                elif b == '╰':
+                    M[i][j] = '┴'
+            elif a == '│':
+                if b == a:
+                    pass
+                elif b == '╮':
+                    M[i][j] = '┤'
+                elif b == '╰':
+                    M[i][j] = '├'
+
+        for i, j in self.poset().hasse_diagram().edges(sort=True, labels=False):
+            if i > j:
+                superpose(i, j, '╰')
+                for k in range(j + 1, i):
+                    superpose(k, j, '│')
+                    superpose(i, k, '─')
+            else:
+                superpose(i, j, '╮')
+                for k in range(i + 1, j):
+                    superpose(i, k, '─')
+                    superpose(k, j, '│')
+
+        from sage.typeset.unicode_art import UnicodeArt
+        return UnicodeArt([''.join(ligne) for ligne in M])
+
+    def _richcmp_(self, other, op) -> bool:
+        r"""
+        Comparison.
+
+        The comparison is first by size, then
+        using cubical coordinates.
+
+        .. SEEALSO:: :meth:`cubical_coordinates`
+
+        TESTS::
+
+            sage: TamariIntervalPoset(0,[]) == TamariIntervalPoset(0,[])
+            True
+            sage: TamariIntervalPoset(1,[]) == TamariIntervalPoset(0,[])
+            False
+            sage: TamariIntervalPoset(3,[(1,2),(3,2)]) == TamariIntervalPoset(3,[(3,2),(1,2)])
+            True
+            sage: TamariIntervalPoset(3,[(1,2),(3,2)]) == TamariIntervalPoset(3,[(1,2)])
+            False
+            sage: TamariIntervalPoset(3,[(1,2),(3,2)]) != TamariIntervalPoset(3,[(3,2),(1,2)])
+            False
+
+            sage: ip1 = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: ip2 = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip1 <= ip2
+            False
+            sage: ip1 <= ip1
+            True
+            sage: ip2 <= ip1
+            True
+
+            sage: ip1 != 33
+            True
+        """
+        if not isinstance(other, TamariIntervalPoset):
+            return NotImplemented
+        if op == op_EQ:
+            return (self.size() == other.size() and
+                    self._cover_relations == other._cover_relations)
+        if op == op_NE:
+            return not (self.size() == other.size() and
+                        self._cover_relations == other._cover_relations)
+        return richcmp((self.size(), self.cubical_coordinates()),
+                       (other.size(), other.cubical_coordinates()), op)
+
+    def __iter__(self) -> Iterator[int]:
+        r"""
+        Iterate through the vertices of ``self``.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(3,2)])
+            sage: [i for i in ip]
+            [1, 2, 3, 4]
+        """
+        return iter(range(1, self.size() + 1))
+
+    def contains_interval(self, other) -> bool:
+        r"""
+        Return whether the interval represented by ``other`` is contained
+        in ``self`` as an interval of the Tamari lattice.
+
+        In terms of interval-posets, it means that all relations of ``self``
+        are relations of ``other``.
+
+        INPUT:
+
+        - ``other`` -- an interval-poset
+
+        EXAMPLES::
+
+            sage: ip1 = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: ip2 = TamariIntervalPoset(4,[(2,3)])
+            sage: ip2.contains_interval(ip1)
+            True
+            sage: ip3 = TamariIntervalPoset(4,[(2,1)])
+            sage: ip2.contains_interval(ip3)
+            False
+            sage: ip4 = TamariIntervalPoset(3,[(2,3)])
+            sage: ip2.contains_interval(ip4)
+            False
+        """
+        if other.size() != self.size():
+            return False
+        return all(other.le(i, j) for (i, j) in self._cover_relations)
+
+    def lower_contains_interval(self, other) -> bool:
+        r"""
+        Return whether the interval represented by ``other`` is contained
+        in ``self`` as an interval of the Tamari lattice and if they share
+        the same lower bound.
+
+        As interval-posets, it means that ``other`` contains the relations
+        of ``self`` plus some extra increasing relations.
+
+        INPUT:
+
+        - ``other`` -- an interval-poset
+
+        EXAMPLES::
+
+            sage: ip1 = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: ip2 = TamariIntervalPoset(4,[(4,3)])
+            sage: ip2.lower_contains_interval(ip1)
+            True
+            sage: ip2.contains_interval(ip1) and ip2.lower_binary_tree() == ip1.lower_binary_tree()
+            True
+            sage: ip3 = TamariIntervalPoset(4,[(4,3),(2,1)])
+            sage: ip2.contains_interval(ip3)
+            True
+            sage: ip2.lower_binary_tree() == ip3.lower_binary_tree()
+            False
+            sage: ip2.lower_contains_interval(ip3)
+            False
+
+        TESTS::
+
+            sage: ip1 = TamariIntervalPoset(3,[(1,2),(2,3)])
+            sage: ip2 = TamariIntervalPoset(3,[(2,1),(3,2)])
+            sage: ip2.lower_contains_interval(ip1)
+            False
+        """
+        if not self.contains_interval(other):
+            return False
+        return all(self.le(i, j)
+                   for (i, j) in other.decreasing_cover_relations())
+
+    def upper_contains_interval(self, other) -> bool:
+        r"""
+        Return whether the interval represented by ``other`` is contained
+        in ``self`` as an interval of the Tamari lattice and if they share
+        the same upper bound.
+
+        As interval-posets, it means that ``other`` contains the relations
+        of ``self`` plus some extra decreasing relations.
+
+        INPUT:
+
+        - ``other`` -- an interval-poset
+
+        EXAMPLES::
+
+            sage: ip1 = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: ip2 = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip2.upper_contains_interval(ip1)
+            True
+            sage: ip2.contains_interval(ip1) and ip2.upper_binary_tree() == ip1.upper_binary_tree()
+            True
+            sage: ip3 = TamariIntervalPoset(4,[(1,2),(2,3),(3,4)])
+            sage: ip2.upper_contains_interval(ip3)
+            False
+            sage: ip2.contains_interval(ip3)
+            True
+            sage: ip2.upper_binary_tree() == ip3.upper_binary_tree()
+            False
+
+        TESTS::
+
+            sage: ip1 = TamariIntervalPoset(3,[(1,2),(2,3)])
+            sage: ip2 = TamariIntervalPoset(3,[(2,1),(3,2)])
+            sage: ip2.lower_contains_interval(ip1)
+            False
+        """
+        if not self.contains_interval(other):
+            return False
+        return all(self.le(i, j)
+                   for (i, j) in other.increasing_cover_relations())
+
+    def is_linear_extension(self, perm) -> bool:
+        r"""
+        Return whether the permutation ``perm`` is a linear extension
+        of ``self``.
+
+        INPUT:
+
+        - ``perm`` -- a permutation of the size of ``self``
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: ip.is_linear_extension([1,4,2,3])
+            True
+            sage: ip.is_linear_extension(Permutation([1,4,2,3]))
+            True
+            sage: ip.is_linear_extension(Permutation([1,4,3,2]))
+            False
+        """
+        return self._poset.is_linear_extension(perm)
+
+    def contains_binary_tree(self, binary_tree) -> bool:
+        r"""
+        Return whether the interval represented by ``self`` contains
+        the binary tree ``binary_tree``.
+
+        INPUT:
+
+        - ``binary_tree`` -- a binary tree
+
+        .. SEEALSO:: :meth:`contains_dyck_word`
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: ip.contains_binary_tree(BinaryTree([[None,[None,[]]],None]))
+            True
+            sage: ip.contains_binary_tree(BinaryTree([None,[[[],None],None]]))
+            True
+            sage: ip.contains_binary_tree(BinaryTree([[],[[],None]]))
+            False
+            sage: ip.contains_binary_tree(ip.lower_binary_tree())
+            True
+            sage: ip.contains_binary_tree(ip.upper_binary_tree())
+            True
+            sage: all(ip.contains_binary_tree(bt) for bt in ip.binary_trees())
+            True
+        """
+        return self.is_linear_extension(binary_tree.to_132_avoiding_permutation())
+
+    def contains_dyck_word(self, dyck_word) -> bool:
+        r"""
+        Return whether the interval represented by ``self`` contains
+        the Dyck word ``dyck_word``.
+
+        INPUT:
+
+        - ``dyck_word`` -- a Dyck word
+
+        .. SEEALSO:: :meth:`contains_binary_tree`
+
+        EXAMPLES::
+
+            sage: # needs sage.combinat
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: ip.contains_dyck_word(DyckWord([1,1,1,0,0,0,1,0]))
+            True
+            sage: ip.contains_dyck_word(DyckWord([1,1,0,1,0,1,0,0]))
+            True
+            sage: ip.contains_dyck_word(DyckWord([1,0,1,1,0,1,0,0]))
+            False
+            sage: ip.contains_dyck_word(ip.lower_dyck_word())
+            True
+            sage: ip.contains_dyck_word(ip.upper_dyck_word())
+            True
+            sage: all(ip.contains_dyck_word(bt) for bt in ip.dyck_words())
+            True
+        """
+        return self.contains_binary_tree(dyck_word.to_binary_tree_tamari())
+
+    def intersection(self, other: TIP) -> TIP:
+        r"""
+        Return the interval-poset formed by combining the relations from
+        both ``self`` and ``other``. It corresponds to the intersection
+        of the two corresponding intervals of the Tamari lattice.
+
+        INPUT:
+
+        - ``other`` -- an interval-poset of the same size as ``self``
+
+        EXAMPLES::
+
+            sage: ip1 = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip2 = TamariIntervalPoset(4,[(4,3)])
+            sage: ip1.intersection(ip2)
+            The Tamari interval of size 4 induced by relations [(1, 2), (2, 3), (4, 3)]
+            sage: ip3 = TamariIntervalPoset(4,[(2,1)])
+            sage: ip1.intersection(ip3)
+            Traceback (most recent call last):
+            ...
+            ValueError: this intersection is empty, it does not correspond to an interval-poset
+            sage: ip4 = TamariIntervalPoset(3,[(2,3)])
+            sage: ip2.intersection(ip4)
+            Traceback (most recent call last):
+            ...
+            ValueError: intersections are only possible on interval-posets of the same size
+        """
+        if other.size() != self.size():
+            raise ValueError("intersections are only possible on interval-posets of the same size")
+        try:
+            return TamariIntervalPoset(self.size(), self._cover_relations + other._cover_relations)
+        except ValueError:
+            raise ValueError("this intersection is empty, it does not correspond to an interval-poset")
+
+    def initial_forest(self) -> TIP:
+        r"""
+        Return the initial forest of ``self``, i.e., the interval-poset
+        formed from only the increasing relations of ``self``.
+
+        .. SEEALSO:: :meth:`final_forest`
+
+        EXAMPLES::
+
+            sage: TamariIntervalPoset(4,[(1,2),(3,2),(2,4),(3,4)]).initial_forest()
+            The Tamari interval of size 4 induced by relations [(1, 2), (2, 4), (3, 4)]
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: ip.initial_forest() == ip
+            True
+        """
+        relations = self.increasing_cover_relations()
+        P = FinitePoset(DiGraph([list(range(1, self._size + 1)), relations],
+                                format='vertices_and_edges'))  # type:ignore
+        return TamariIntervalPoset(P, check=False)  # type:ignore
+
+    def final_forest(self) -> TIP:
+        r"""
+        Return the final forest of ``self``, i.e., the interval-poset
+        formed with only the decreasing relations of ``self``.
+
+        .. SEEALSO:: :meth:`initial_forest`
+
+        EXAMPLES::
+
+            sage: TamariIntervalPoset(4,[(2,1),(3,2),(3,4),(4,2)]).final_forest()
+            The Tamari interval of size 4 induced by relations [(4, 2), (3, 2), (2, 1)]
+            sage: ip = TamariIntervalPoset(3,[(2,1),(3,1)])
+            sage: ip.final_forest() == ip
+            True
+        """
+        relations = self.decreasing_cover_relations()
+        P = FinitePoset(DiGraph([list(range(1, self._size + 1)), relations],
+                                format='vertices_and_edges'))  # type:ignore
+        return TamariIntervalPoset(P, check=False)  # type:ignore
+
+    def is_initial_interval(self) -> bool:
+        r"""
+        Return if ``self`` corresponds to an initial interval of the Tamari
+        lattice.
+
+        This means that its lower end is the smallest element of the lattice.
+        It consists of checking that ``self`` does not contain any decreasing
+        relations.
+
+        .. SEEALSO:: :meth:`is_final_interval`
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4, [(1, 2), (2, 4), (3, 4)])
+            sage: ip.is_initial_interval()
+            True
+            sage: ip.lower_dyck_word()                                                  # needs sage.combinat
+            [1, 0, 1, 0, 1, 0, 1, 0]
+            sage: ip = TamariIntervalPoset(4, [(1, 2), (2, 4), (3, 4), (3, 2)])
+            sage: ip.is_initial_interval()
+            False
+            sage: ip.lower_dyck_word()                                                  # needs sage.combinat
+            [1, 0, 1, 1, 0, 0, 1, 0]
+            sage: all(DyckWord([1,0,1,0,1,0]).tamari_interval(dw)                       # needs sage.combinat
+            ....:         .is_initial_interval()
+            ....:     for dw in DyckWords(3))
+            True
+        """
+        return not self.decreasing_cover_relations()
+
+    def is_final_interval(self) -> bool:
+        r"""
+        Return if ``self`` corresponds to a final interval of the Tamari
+        lattice.
+
+        This means that its upper end is the largest element of the lattice.
+        It consists of checking that ``self`` does not contain any increasing
+        relations.
+
+        .. SEEALSO:: :meth:`is_initial_interval`
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4, [(4, 3), (3, 1), (2, 1)])
+            sage: ip.is_final_interval()
+            True
+            sage: ip.upper_dyck_word()                                                  # needs sage.combinat
+            [1, 1, 1, 1, 0, 0, 0, 0]
+            sage: ip = TamariIntervalPoset(4, [(4, 3), (3, 1), (2, 1), (2, 3)])
+            sage: ip.is_final_interval()
+            False
+            sage: ip.upper_dyck_word()                                                  # needs sage.combinat
+            [1, 1, 0, 1, 1, 0, 0, 0]
+            sage: all(dw.tamari_interval(DyckWord([1, 1, 1, 0, 0, 0]))                  # needs sage.combinat
+            ....:            .is_final_interval()
+            ....:     for dw in DyckWords(3))
+            True
+        """
+        return not self.increasing_cover_relations()
+
+    def lower_binary_tree(self):
+        r"""
+        Return the lowest binary tree in the interval of the Tamari
+        lattice represented by ``self``.
+
+        This is a binary tree. It is the shape of the unique binary
+        search tree whose left-branch ordered forest (i.e., the result
+        of applying
+        :meth:`~sage.combinat.binary_tree.BinaryTree.to_ordered_tree_left_branch`
+        and cutting off the root) is the final forest of ``self``.
+
+        .. SEEALSO:: :meth:`lower_dyck_word`
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(6, [(3,2),(4,3),(5,2),(6,5),(1,2),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations
+             [(1, 2), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.lower_binary_tree()
+            [[., .], [[., [., .]], [., .]]]
+            sage: ff = TamariIntervalPosets.final_forest(ip.lower_binary_tree())
+            sage: ff == ip.final_forest()
+            True
+            sage: ip == TamariIntervalPosets.from_binary_trees(ip.lower_binary_tree(),
+            ....:                                              ip.upper_binary_tree())
+            True
+        """
+        return self.min_linear_extension().binary_search_tree_shape(left_to_right=False)
+
+    def lower_dyck_word(self):
+        r"""
+        Return the lowest Dyck word in the interval of the Tamari lattice
+        represented by ``self``.
+
+        .. SEEALSO:: :meth:`lower_binary_tree`
+
+        EXAMPLES::
+
+            sage: # needs sage.combinat
+            sage: ip = TamariIntervalPoset(6, [(3,2),(4,3),(5,2),(6,5),(1,2),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations
+             [(1, 2), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.lower_dyck_word()
+            [1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0]
+            sage: ldw_ff = TamariIntervalPosets.final_forest(ip.lower_dyck_word())
+            sage: ldw_ff == ip.final_forest()
+            True
+            sage: ip == TamariIntervalPosets.from_dyck_words(ip.lower_dyck_word(),
+            ....:                                            ip.upper_dyck_word())
+            True
+        """
+        return self.lower_binary_tree().to_dyck_word_tamari()
+
+    def upper_binary_tree(self):
+        r"""
+        Return the highest binary tree in the interval of the Tamari
+        lattice represented by ``self``.
+
+        This is a binary tree. It is the shape of the unique binary
+        search tree whose right-branch ordered forest (i.e., the result
+        of applying
+        :meth:`~sage.combinat.binary_tree.BinaryTree.to_ordered_tree_right_branch`
+        and cutting off the root) is the initial forest of ``self``.
+
+        .. SEEALSO:: :meth:`upper_dyck_word`
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations
+             [(1, 2), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.upper_binary_tree()
+            [[., .], [., [[., .], [., .]]]]
+
+            sage: TamariIntervalPosets.initial_forest(ip.upper_binary_tree()) == ip.initial_forest()
+            True
+            sage: ip == TamariIntervalPosets.from_binary_trees(ip.lower_binary_tree(),ip.upper_binary_tree())
+            True
+        """
+        return self.max_linear_extension().binary_search_tree_shape(left_to_right=False)
+
+    def upper_dyck_word(self):
+        r"""
+        Return the highest Dyck word in the interval of the Tamari lattice
+        represented by ``self``.
+
+        .. SEEALSO:: :meth:`upper_binary_tree`
+
+        EXAMPLES::
+
+            sage: # needs sage.combinat
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations
+             [(1, 2), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.upper_dyck_word()
+            [1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0]
+            sage: udw_if = TamariIntervalPosets.initial_forest(ip.upper_dyck_word())
+            sage: udw_if == ip.initial_forest()
+            True
+            sage: ip == TamariIntervalPosets.from_dyck_words(ip.lower_dyck_word(),
+            ....:                                            ip.upper_dyck_word())
+            True
+        """
+        return self.upper_binary_tree().to_dyck_word_tamari()
+
+    def subposet(self, start, end) -> TIP:
+        r"""
+        Return the renormalized subposet of ``self`` consisting solely
+        of integers from ``start`` (inclusive) to ``end`` (not inclusive).
+
+        "Renormalized" means that these integers are relabelled
+        `1,2,\ldots,k` in the obvious way (i.e., by subtracting
+        ``start - 1``).
+
+        INPUT:
+
+        - ``start`` -- integer; the starting vertex (inclusive)
+        - ``end`` -- integer; the ending vertex (not inclusive)
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(6, [(3,2),(4,3),(5,2),(6,5),(1,2),(3,5),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations
+             [(1, 2), (3, 5), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.subposet(1,3)
+            The Tamari interval of size 2 induced by relations [(1, 2)]
+            sage: ip.subposet(1,4)
+            The Tamari interval of size 3 induced by relations [(1, 2), (3, 2)]
+            sage: ip.subposet(1,5)
+            The Tamari interval of size 4 induced by relations [(1, 2), (4, 3), (3, 2)]
+            sage: ip.subposet(1,7) == ip
+            True
+            sage: ip.subposet(1,1)
+            The Tamari interval of size 0 induced by relations []
+
+        TESTS::
+
+            sage: ip.sub_poset(1,1)
+            The Tamari interval of size 0 induced by relations []
+            sage: ip = TamariIntervalPosets(4).an_element()
+            sage: ip.subposet(2,9)
+            Traceback (most recent call last):
+            ...
+            ValueError: invalid starting or ending value
+        """
+        if start < 1 or start > end or end > self.size() + 1:
+            raise ValueError("invalid starting or ending value")
+        if start == end:
+            return TamariIntervalPoset(0, [])
+        relations = [(i - start + 1, j - start + 1)
+                     for (i, j) in self.increasing_cover_relations()
+                     if i >= start and j < end]
+        relations.extend((j - start + 1, i - start + 1)
+                         for (j, i) in self.decreasing_cover_relations()
+                         if i >= start and j < end)
+        return TamariIntervalPoset(end - start, relations, check=False)
+
+    sub_poset = subposet
+
+    def min_linear_extension(self) -> Permutation:
+        r"""
+        Return the minimal permutation for the right weak order which is
+        a linear extension of ``self``.
+
+        This is also the minimal permutation in the sylvester
+        class of ``self.lower_binary_tree()`` and is a 312-avoiding
+        permutation.
+
+        The right weak order is also known as the right permutohedron
+        order. See
+        :meth:`~sage.combinat.permutation.Permutation.permutohedron_lequal`
+        for its definition.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: ip.min_linear_extension()
+            [1, 2, 4, 3]
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(4,5)])
+            sage: ip.min_linear_extension()
+            [1, 4, 3, 6, 5, 2]
+            sage: ip = TamariIntervalPoset(0,[])
+            sage: ip.min_linear_extension()
+            []
+            sage: ip = TamariIntervalPoset(5, [(1, 4), (2, 4), (3, 4), (5, 4)]); ip
+            The Tamari interval of size 5 induced by relations [(1, 4), (2, 4), (3, 4), (5, 4)]
+            sage: ip.min_linear_extension()
+            [1, 2, 3, 5, 4]
+        """
+        # The min linear extension is built by postfix-reading the
+        # final forest of ``self``.
+        final_forest = DiGraph([list(self),
+                                self.decreasing_cover_relations()],
+                               format='vertices_and_edges')
+
+        def add(perm: list, i):
+            r"""
+            Internal recursive method to compute the min linear extension.
+            """
+            for j in sorted(final_forest.neighbors_in(i)):
+                add(perm, j)
+            perm.append(i)
+        perm: list[int] = []
+        for i in sorted(final_forest.sinks()):
+            add(perm, i)
+        return Permutation(perm)  # type:ignore
+
+    def max_linear_extension(self) -> Permutation:
+        r"""
+        Return the maximal permutation for the right weak order which is
+        a linear extension of ``self``.
+
+        This is also the maximal permutation in the sylvester
+        class of ``self.upper_binary_tree()`` and is a 132-avoiding
+        permutation.
+
+        The right weak order is also known as the right permutohedron
+        order. See
+        :meth:`~sage.combinat.permutation.Permutation.permutohedron_lequal`
+        for its definition.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: ip.max_linear_extension()
+            [4, 1, 2, 3]
+            sage: ip = TamariIntervalPoset(6,[(3,2),(4,3),(5,2),(6,5),(1,2),(4,5)]); ip
+            The Tamari interval of size 6 induced by relations [(1, 2), (4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: ip.max_linear_extension()
+            [6, 4, 5, 3, 1, 2]
+            sage: ip = TamariIntervalPoset(0,[]); ip
+            The Tamari interval of size 0 induced by relations []
+            sage: ip.max_linear_extension()
+            []
+            sage: ip = TamariIntervalPoset(5, [(1, 4), (2, 4), (3, 4), (5, 4)]); ip
+            The Tamari interval of size 5 induced by relations [(1, 4), (2, 4), (3, 4), (5, 4)]
+            sage: ip.max_linear_extension()
+            [5, 3, 2, 1, 4]
+        """
+        # The max linear extension is built by right-to-left
+        # postfix-reading the initial forest of ``self``.
+        initial_forest = DiGraph([list(self),
+                                  self.increasing_cover_relations()],
+                                 format='vertices_and_edges')
+
+        def add(perm: list, i):
+            r"""
+            Internal recursive method to compute the max linear extension.
+            """
+            for j in sorted(initial_forest.neighbors_in(i), reverse=True):
+                add(perm, j)
+            perm.append(i)
+        perm: list[int] = []
+        for i in sorted(initial_forest.sinks(), reverse=True):
+            add(perm, i)
+        return Permutation(perm)  # type:ignore
+
+    def linear_extensions(self) -> Iterator[Permutation]:
+        r"""
+        Return an iterator on the permutations which are linear
+        extensions of ``self``.
+
+        They form an interval of the right weak order (also called the
+        right permutohedron order -- see
+        :meth:`~sage.combinat.permutation.Permutation.permutohedron_lequal`
+        for a definition).
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(3, [(1,2),(3,2)])
+            sage: list(ip.linear_extensions())                                          # needs sage.modules sage.rings.finite_rings
+            [[3, 1, 2], [1, 3, 2]]
+            sage: ip = TamariIntervalPoset(4, [(1,2),(2,3),(4,3)])
+            sage: list(ip.linear_extensions())                                          # needs sage.modules sage.rings.finite_rings
+            [[4, 1, 2, 3], [1, 2, 4, 3], [1, 4, 2, 3]]
+        """
+        for ext in self._poset.linear_extensions():
+            yield Permutation(ext)  # type:ignore
+
+    def lower_contained_intervals(self) -> Iterator[TIP]:
+        r"""
+        If ``self`` represents the interval `[t_1, t_2]` of the Tamari
+        lattice, return an iterator on all intervals `[t_1,t]` with
+        `t \leq t_2` for the Tamari lattice.
+
+        In terms of interval-posets, it corresponds to adding all possible
+        relations of the form `n` precedes `m` with `n<m`.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4, [(2,4),(3,4),(2,1),(3,1)])
+            sage: list(ip.lower_contained_intervals())
+            [The Tamari interval of size 4 induced by relations
+              [(2, 4), (3, 4), (3, 1), (2, 1)],
+             The Tamari interval of size 4 induced by relations
+              [(1, 4), (2, 4), (3, 4), (3, 1), (2, 1)],
+             The Tamari interval of size 4 induced by relations
+              [(2, 3), (3, 4), (3, 1), (2, 1)],
+             The Tamari interval of size 4 induced by relations
+              [(1, 4), (2, 3), (3, 4), (3, 1), (2, 1)]]
+            sage: ip = TamariIntervalPoset(4,[])
+            sage: len(list(ip.lower_contained_intervals()))
+            14
+        """
+        size = self._size
+        yield self
+        r"""
+        we try to add links recursively in this order:
+        1 -> 2
+        2 -> 3
+        1 -> 3
+        3 -> 4
+        2 -> 4
+        1 -> 4
+        ...
+        ("Link" means "relation of the poset".)
+
+        One useful feature of interval-posets is that if you add a single
+        new relation -- say, `x` precedes `y` -- to an existing
+        interval-poset and take the transitive closure, and if the axioms
+        of an interval-poset are still satisfied for `(a,c) = (x,y)` and
+        for `(a,c) = (y,x)`, then the transitive closure is an
+        interval-poset (i.e., roughly speaking, the other new relations
+        forced by `x` preceding `y` under transitive closure cannot
+        invalidate the axioms). This is helpful when extending
+        interval-posets, and is the reason why this and other iterators
+        don't yield invalid interval-posets.
+        """
+        def add_relations(poset, n, m):
+            r"""
+            Internal recursive method to generate all possible intervals.
+            At every step during the iteration, we have n < m and every
+            i satisfying n < i < m satisfies that i precedes m in the
+            poset ``poset`` (except when m > size).
+            """
+            if n <= 0:
+                # if n<=0, then we go to the next m
+                n = m
+                m += 1
+            if m > size:
+                # if m>size, it's finished
+                return
+
+            if poset.le(n, m):
+                # there is already a link n->m, so we go to the next n
+                yield from add_relations(poset, n - 1, m)
+            elif poset.le(m, n):
+                # there is an inverse link m->n, we know we won't be able
+                # to create a link i->m with i<=n, so we go to the next m
+                yield from add_relations(poset, m, m + 1)
+            else:
+                # there is no link n->m
+                # first option : we don't create the link and go to the next m
+                # (since the lack of a link n->m forbids any links i->m
+                # with i<n)
+                yield from add_relations(poset, m, m + 1)
+                # second option : we create the link
+                # (this is allowed because links i->m already exist for all
+                # n<i<m, or else we wouldn't be here)
+                poset = TamariIntervalPoset(poset.size(), poset._cover_relations + ((n, m),))
+                yield poset
+                # and then, we go to the next n
+                yield from add_relations(poset, n - 1, m)
+
+        yield from add_relations(self, 1, 2)
+
+    def interval_cardinality(self) -> Integer:
+        r"""
+        Return the cardinality of the interval, i.e., the number of elements
+        (binary trees or Dyck words) in the interval represented by ``self``.
+
+        Not to be confused with :meth:`size` which is the number of
+        vertices.
+
+        .. SEEALSO:: :meth:`binary_trees`
+
+        EXAMPLES::
+
+            sage: TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)]).interval_cardinality()
+            4
+            sage: TamariIntervalPoset(4,[]).interval_cardinality()
+            14
+            sage: TamariIntervalPoset(4,[(1,2),(2,3),(3,4)]).interval_cardinality()
+            1
+        """
+        return len(list(self.lower_contained_intervals()))
+
+    def binary_trees(self) -> Iterator:
+        r"""
+        Return an iterator on all the binary trees in the interval
+        represented by ``self``.
+
+        .. SEEALSO:: :meth:`interval_cardinality`
+
+        EXAMPLES::
+
+            sage: list(TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)]).binary_trees())
+            [[., [[., [., .]], .]],
+             [[., [., [., .]]], .],
+             [., [[[., .], .], .]],
+             [[., [[., .], .]], .]]
+            sage: set(TamariIntervalPoset(4,[]).binary_trees()) == set(BinaryTrees(4))
+            True
+        """
+        for ip in self.lower_contained_intervals():
+            yield ip.upper_binary_tree()
+
+    def dyck_words(self) -> Iterator:
+        r"""
+        Return an iterator on all the Dyck words in the interval
+        represented by ``self``.
+
+        EXAMPLES::
+
+            sage: list(TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)]).dyck_words())   # needs sage.combinat
+            [[1, 1, 1, 0, 0, 1, 0, 0],
+             [1, 1, 1, 0, 0, 0, 1, 0],
+             [1, 1, 0, 1, 0, 1, 0, 0],
+             [1, 1, 0, 1, 0, 0, 1, 0]]
+            sage: set(TamariIntervalPoset(4,[]).dyck_words()) == set(DyckWords(4))      # needs sage.combinat
+            True
+        """
+        for ip in self.lower_contained_intervals():
+            yield ip.upper_dyck_word()
+
+    def maximal_chain_tamari_intervals(self) -> Iterator[TIP]:
+        r"""
+        Return an iterator on the upper contained intervals of one
+        longest chain of the Tamari interval represented by ``self``.
+
+        If ``self`` represents the interval `[T_1,T_2]` of the Tamari
+        lattice, this returns intervals `[T',T_2]` with `T'` following
+        one longest chain between `T_1` and `T_2`.
+
+        To obtain a longest chain, we use the Tamari inversions of ``self``.
+        The elements of the chain are obtained by adding one by one the
+        relations `(b,a)` from each Tamari inversion `(a,b)` to ``self``,
+        where the Tamari inversions are taken in lexicographic order.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4, [(2,4),(3,4),(2,1),(3,1)])
+            sage: list(ip.maximal_chain_tamari_intervals())
+            [The Tamari interval of size 4 induced by relations
+              [(2, 4), (3, 4), (3, 1), (2, 1)],
+             The Tamari interval of size 4 induced by relations
+              [(2, 4), (3, 4), (4, 1), (3, 1), (2, 1)],
+             The Tamari interval of size 4 induced by relations
+              [(2, 4), (3, 4), (4, 1), (3, 2), (2, 1)]]
+            sage: ip = TamariIntervalPoset(4, [])
+            sage: list(ip.maximal_chain_tamari_intervals())
+            [The Tamari interval of size 4 induced by relations [],
+             The Tamari interval of size 4 induced by relations [(2, 1)],
+             The Tamari interval of size 4 induced by relations [(3, 1), (2, 1)],
+             The Tamari interval of size 4 induced by relations [(4, 1), (3, 1), (2, 1)],
+             The Tamari interval of size 4 induced by relations [(4, 1), (3, 2), (2, 1)],
+             The Tamari interval of size 4 induced by relations [(4, 2), (3, 2), (2, 1)],
+             The Tamari interval of size 4 induced by relations [(4, 3), (3, 2), (2, 1)]]
+        """
+        yield self
+        n = self.size()
+        cover_relations = list(self._cover_relations)
+        for inv in self.tamari_inversions_iter():
+            cover_relations.append((inv[1], inv[0]))
+            yield TamariIntervalPoset(n, cover_relations, check=False)
+
+    def maximal_chain_binary_trees(self) -> Iterator:
+        r"""
+        Return an iterator on the binary trees forming a longest chain of
+        ``self`` (regarding ``self`` as an interval of the Tamari
+        lattice).
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: list(ip.maximal_chain_binary_trees())
+            [[[., [[., .], .]], .], [., [[[., .], .], .]], [., [[., [., .]], .]]]
+            sage: ip = TamariIntervalPoset(4,[])
+            sage: list(ip.maximal_chain_binary_trees())
+            [[[[[., .], .], .], .],
+             [[[., [., .]], .], .],
+             [[., [[., .], .]], .],
+             [., [[[., .], .], .]],
+             [., [[., [., .]], .]],
+             [., [., [[., .], .]]],
+             [., [., [., [., .]]]]]
+        """
+        for it in self.maximal_chain_tamari_intervals():
+            yield it.lower_binary_tree()
+
+    def maximal_chain_dyck_words(self) -> Iterator:
+        r"""
+        Return an iterator on the Dyck words forming a longest chain of
+        ``self`` (regarding ``self`` as an interval of the Tamari
+        lattice).
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: list(ip.maximal_chain_dyck_words())                                   # needs sage.combinat
+            [[1, 1, 0, 1, 0, 0, 1, 0], [1, 1, 0, 1, 0, 1, 0, 0], [1, 1, 1, 0, 0, 1, 0, 0]]
+            sage: ip = TamariIntervalPoset(4,[])
+            sage: list(ip.maximal_chain_dyck_words())                                   # needs sage.combinat
+            [[1, 0, 1, 0, 1, 0, 1, 0],
+             [1, 1, 0, 0, 1, 0, 1, 0],
+             [1, 1, 0, 1, 0, 0, 1, 0],
+             [1, 1, 0, 1, 0, 1, 0, 0],
+             [1, 1, 1, 0, 0, 1, 0, 0],
+             [1, 1, 1, 0, 1, 0, 0, 0],
+             [1, 1, 1, 1, 0, 0, 0, 0]]
+        """
+        for it in self.maximal_chain_tamari_intervals():
+            yield it.lower_dyck_word()
+
+    def tamari_inversions(self) -> list[tuple[int, int]]:
+        r"""
+        Return the Tamari inversions of ``self``.
+
+        A Tamari inversion is
+        a pair of vertices `(a,b)` with `a < b` such that:
+
+        - the decreasing parent of `b` is strictly smaller than `a` (or
+          does not exist), and
+        - the increasing parent of `a` is strictly bigger than `b` (or
+          does not exist).
+
+        "Smaller" and "bigger" refer to the numerical values of the
+        elements, not to the poset order.
+
+        This method returns the list of all Tamari inversions in
+        lexicographic order.
+
+        The number of Tamari inversions is the length of the
+        longest chain of the Tamari interval represented by ``self``.
+
+        Indeed, when an interval consists of just one binary tree, it has
+        no inversion. One can also prove that if a Tamari interval
+        `I' = [T_1', T_2']` is a proper subset of a Tamari interval
+        `I = [T_1, T_2]`, then the inversion number of `I'` is strictly
+        lower than the inversion number of `I`. And finally, by adding
+        the relation `(b,a)` to the interval-poset where `(a,b)` is the
+        first inversion of `I` in lexicographic order, one reduces the
+        inversion number by exactly `1`.
+
+        .. SEEALSO::
+
+            :meth:`tamari_inversions_iter`, :meth:`number_of_tamari_inversions`
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(3,[])
+            sage: ip.tamari_inversions()
+            [(1, 2), (1, 3), (2, 3)]
+            sage: ip = TamariIntervalPoset(3,[(2,1)])
+            sage: ip.tamari_inversions()
+            [(1, 3), (2, 3)]
+            sage: ip = TamariIntervalPoset(3,[(1,2)])
+            sage: ip.tamari_inversions()
+            [(2, 3)]
+            sage: ip = TamariIntervalPoset(3,[(1,2),(3,2)])
+            sage: ip.tamari_inversions()
+            []
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: ip.tamari_inversions()
+            [(1, 4), (2, 3)]
+            sage: ip = TamariIntervalPoset(4,[])
+            sage: ip.tamari_inversions()
+            [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+            sage: all(not TamariIntervalPosets.from_binary_trees(bt,bt)                 # needs sage.combinat
+            ....:                                  .tamari_inversions()
+            ....:     for bt in BinaryTrees(3))
+            True
+            sage: all(not TamariIntervalPosets.from_binary_trees(bt,bt)                 # needs sage.combinat
+            ....:                                  .tamari_inversions()
+            ....:     for bt in BinaryTrees(4))
+            True
+        """
+        return list(self.tamari_inversions_iter())
+
+    def tamari_inversions_iter(self) -> Iterator[tuple[int, int]]:
+        r"""
+        Iterate over the Tamari inversions of ``self``, in
+        lexicographic order.
+
+        See :meth:`tamari_inversions` for the definition of the terms
+        involved.
+
+        EXAMPLES::
+
+            sage: T = TamariIntervalPoset(5, [[1,2],[3,4],[3,2],[5,2],[4,2]])
+            sage: list(T.tamari_inversions_iter())
+            [(4, 5)]
+
+            sage: T = TamariIntervalPoset(8, [(2, 7), (3, 7), (4, 7), (5, 7), (6, 7),
+            ....:                             (8, 7), (6, 4), (5, 4), (4, 3), (3, 2)])
+            sage: list(T.tamari_inversions_iter())
+            [(1, 2), (1, 7), (5, 6)]
+
+            sage: T = TamariIntervalPoset(1, [])
+            sage: list(T.tamari_inversions_iter())
+            []
+
+            sage: T = TamariIntervalPoset(0, [])
+            sage: list(T.tamari_inversions_iter())
+            []
+        """
+        final_forest = DiGraph([list(self),
+                                self.decreasing_cover_relations()],
+                               format='vertices_and_edges')
+        initial_forest = DiGraph([list(self),
+                                  self.increasing_cover_relations()],
+                                 format='vertices_and_edges')
+        n1 = self.size() + 1
+        for a in range(1, self.size()):   # a == n will never work
+            try:
+                ipa = next(initial_forest.neighbor_out_iterator(a))
+                max_b_1 = ipa
+            except StopIteration:
+                max_b_1 = n1
+            for b in range(a + 1, max_b_1):
+                try:
+                    dpb = next(final_forest.neighbor_out_iterator(b))
+                    if dpb < a:
+                        yield (a, b)
+                except StopIteration:
+                    yield (a, b)
+
+    def number_of_tamari_inversions(self) -> Integer:
+        r"""
+        Return the number of Tamari inversions of ``self``.
+
+        This is also the length the longest chain of the Tamari
+        interval represented by ``self``.
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(2,4),(3,4),(2,1),(3,1)])
+            sage: ip.number_of_tamari_inversions()
+            2
+            sage: ip = TamariIntervalPoset(4,[])
+            sage: ip.number_of_tamari_inversions()
+            6
+            sage: ip = TamariIntervalPoset(3,[])
+            sage: ip.number_of_tamari_inversions()
+            3
+        """
+        return len(self.tamari_inversions())
+
+    def number_of_new_components(self) -> Integer:
+        """
+        Return the number of terms in the decomposition in new interval-posets.
+
+        Every interval-poset has a unique decomposition as a planar tree
+        of new interval-posets, as explained in [Cha2008]_. This function
+        just computes the number of terms, not the planar tree nor
+        the terms themselves.
+
+        .. SEEALSO:: :meth:`is_new`, :meth:`new_decomposition`
+
+        EXAMPLES::
+
+            sage: TIP4 = TamariIntervalPosets(4)
+            sage: nb = [u.number_of_new_components() for u in TIP4]
+            sage: [nb.count(i) for i in range(1, 5)]
+            [12, 21, 21, 14]
+        """
+        t_low = self.lower_binary_tree().to_tilting()
+        t_up = self.upper_binary_tree().to_tilting()
+        return sum(1 for p in t_low if p in t_up)
+
+    def new_decomposition(self) -> list[TIP]:
+        """
+        Return the decomposition of the interval-poset into
+        new interval-posets.
+
+        Every interval-poset has a unique decomposition as a planar
+        tree of new interval-posets, as explained in
+        [Cha2008]_. This function computes the terms of this
+        decomposition, but not the planar tree.
+
+        For the number of terms, you can use instead the method
+        :meth:`number_of_new_components`.
+
+        OUTPUT: list of new interval-posets
+
+        .. SEEALSO::
+
+            :meth:`number_of_new_components`, :meth:`is_new`
+
+        EXAMPLES::
+
+            sage: ex = TamariIntervalPosets(4)[11]
+            sage: ex.number_of_new_components()
+            3
+            sage: ex.new_decomposition()                                                # needs sage.combinat
+            [The Tamari interval of size 1 induced by relations [],
+             The Tamari interval of size 2 induced by relations [],
+             The Tamari interval of size 1 induced by relations []]
+
+        TESTS::
+
+            sage: # needs sage.combinat
+            sage: ex = TamariIntervalPosets(4).random_element()
+            sage: dec = ex.new_decomposition()
+            sage: len(dec) == ex.number_of_new_components()
+            True
+            sage: all(u.is_new() for u in dec)
+            True
+        """
+        from sage.combinat.binary_tree import BinaryTree
+        t_low = self.lower_binary_tree().to_tilting()
+        t_up = self.upper_binary_tree().to_tilting()
+        common = [p for p in t_low if p in t_up]
+
+        def extract_tree(x, y, tilt, common):
+            """
+            Extract a tree with root at position xy (recursive).
+            """
+            left_tree = None
+            for k in range(y - 1, x, -1):
+                if (x, k) in tilt:
+                    if (x, k) not in common:
+                        left_tree = extract_tree(x, k, tilt, common)
+                    break
+            right_tree = None
+            for k in range(x + 1, y):
+                if (k, y) in tilt:
+                    if (k, y) not in common:
+                        right_tree = extract_tree(k, y, tilt, common)
+                    break
+            return BinaryTree([left_tree, right_tree], check=False)
+
+        tip = self.parent()
+        return [tip.from_binary_trees(extract_tree(cx, cy, t_low, common),
+                                      extract_tree(cx, cy, t_up, common))
+                for cx, cy in common]
+
+    def decomposition_to_triple(self) -> None | tuple[TIP, TIP, int]:
+        """
+        Decompose an interval-poset into a triple (``left``, ``right``, ``r``).
+
+        For the inverse method, see
+        :meth:`TamariIntervalPosets.recomposition_from_triple`.
+
+        OUTPUT:
+
+        a triple (``left``, ``right``, ``r``) where ``left`` and
+        ``right`` are interval-posets and ``r`` (an integer) is the
+        parameter of the decomposition.
+
+        EXAMPLES::
+
+            sage: tip = TamariIntervalPoset(8, [(1,2), (2,4), (3,4), (6,7),
+            ....:                               (3,2), (5,4), (6,4), (8,7)])
+            sage: tip.decomposition_to_triple()
+            (The Tamari interval of size 3 induced by relations [(1, 2), (3, 2)],
+             The Tamari interval of size 4 induced by relations [(2, 3), (4, 3)],
+             2)
+            sage: tip == TamariIntervalPosets.recomposition_from_triple(
+            ....:            *tip.decomposition_to_triple())
+            True
+
+        TESTS::
+
+            sage: tip = TamariIntervalPoset(0, [])
+            sage: tip.decomposition_to_triple()
+
+        REFERENCES:
+
+        - [CP2015]_
+        """
+        n = self.size()
+        if n == 0:
+            return None
+        root = self.increasing_roots()[-1]
+        r = len(self.decreasing_children(root))
+        left = self.subposet(1, root)
+        right = self.subposet(root + 1, n + 1)
+        return left, right, r
+
+    def grafting_tree(self) -> LabelledBinaryTree:
+        """
+        Return the grafting tree of the interval-poset.
+
+        For the inverse method,
+        see :meth:`TamariIntervalPosets.from_grafting_tree`.
+
+        EXAMPLES::
+
+            sage: tip = TamariIntervalPoset(8, [(1,2), (2,4), (3,4), (6,7),
+            ....:                               (3,2), (5,4), (6,4), (8,7)])
+            sage: tip.grafting_tree()
+            2[1[0[., .], 0[., .]], 0[., 1[0[., .], 0[., .]]]]
+            sage: tip == TamariIntervalPosets.from_grafting_tree(tip.grafting_tree())
+            True
+
+        REFERENCES:
+
+        - [Pons2018]_
+        """
+        n = self.size()
+        if n == 0:
+            return LabelledBinaryTree(None)  # type:ignore
+        triplet = self.decomposition_to_triple()
+        assert triplet is not None
+        left, right, r = triplet
+        return LabelledBinaryTree([left.grafting_tree(),
+                                   right.grafting_tree()], label=r)
+
+    def is_new(self) -> bool:
+        """
+        Return whether ``self`` is a new Tamari interval.
+
+        Here 'new' means that the interval is not contained in any
+        facet of the associahedron.
+        This condition is invariant under complementation.
+
+        They have been considered in section 9 of [Cha2008]_.
+
+        .. SEEALSO:: :meth:`is_modern`
+
+        EXAMPLES::
+
+            sage: TIP4 = TamariIntervalPosets(4)
+            sage: len([u for u in TIP4 if u.is_new()])
+            12
+
+            sage: TIP3 = TamariIntervalPosets(3)
+            sage: len([u for u in TIP3 if u.is_new()])
+            3
+        """
+        c_up = self.upper_binary_tree().single_edge_cut_shapes()
+        c_down = self.lower_binary_tree().single_edge_cut_shapes()
+        return not any(x in c_up for x in c_down)
+
+    def is_simple(self) -> bool:
+        """
+        Return whether ``self`` is a simple Tamari interval.
+
+        Here 'simple' means that the interval contains a unique binary tree.
+
+        These intervals define the simple modules over the
+        incidence algebras of the Tamari lattices.
+
+        .. SEEALSO:: :meth:`is_final_interval`, :meth:`is_initial_interval`
+
+        EXAMPLES::
+
+            sage: TIP4 = TamariIntervalPosets(4)
+            sage: len([u for u in TIP4 if u.is_simple()])
+            14
+
+            sage: TIP3 = TamariIntervalPosets(3)
+            sage: len([u for u in TIP3 if u.is_simple()])
+            5
+        """
+        return self.upper_binary_tree() == self.lower_binary_tree()
+
+    def is_synchronized(self) -> bool:
+        """
+        Return whether ``self`` is a synchronized Tamari interval.
+
+        This means that the upper and lower binary trees have the same canopee.
+        This condition is invariant under complementation.
+
+        This has been considered in [FPR2015]_. The numbers of
+        synchronized intervals are given by the sequence :oeis:`A000139`.
+
+        EXAMPLES::
+
+            sage: len([T for T in TamariIntervalPosets(3)
+            ....:     if T.is_synchronized()])
+            6
+        """
+        up = self.upper_binary_tree()
+        down = self.lower_binary_tree()
+        return down.canopee() == up.canopee()
+
+    def is_modern(self) -> bool:
+        r"""
+        Return whether ``self`` is a modern Tamari interval.
+
+        This is defined by exclusion of a simple pattern in the Hasse diagram,
+        namely there is no configuration `y \rightarrow x \leftarrow z`
+        with `1 \leq y < x < z \leq n`.
+
+        This condition is invariant under complementation.
+
+        .. SEEALSO:: :meth:`is_new`, :meth:`is_infinitely_modern`
+
+        EXAMPLES::
+
+            sage: len([T for T in TamariIntervalPosets(3) if T.is_modern()])
+            12
+
+        REFERENCES:
+
+        - [Rog2018]_
+        """
+        G = self.poset().hasse_diagram()
+        for x in G:
+            nx = G.neighbors_in(x)
+            nx.append(x)
+            if min(nx) < x < max(nx):
+                return False
+        return True
+
+    def is_infinitely_modern(self) -> bool:
+        r"""
+        Return whether ``self`` is an infinitely-modern Tamari interval.
+
+        This is defined by the exclusion of the configuration
+        `i \rightarrow i + 1` and `j + 1 \rightarrow j` with `i < j`.
+
+        This condition is invariant under complementation.
+
+        .. SEEALSO:: :meth:`is_new`, :meth:`is_modern`
+
+        EXAMPLES::
+
+            sage: len([T for T in TamariIntervalPosets(3)
+            ....:     if T.is_infinitely_modern()])
+            12
+
+        REFERENCES:
+
+        - [Rog2018]_
+        """
+        n = self.size()
+        found = False
+        for i in range(1, n):
+            if self.le(i, i + 1):
+                found = True
+                continue
+            if self.le(i + 1, i) and found:
+                return False
+        return True
+
+    def is_exceptional(self) -> bool:
+        r"""
+        Return whether ``self`` is an exceptional Tamari interval.
+
+        This is defined by exclusion of a simple pattern in the Hasse diagram,
+        namely there is no configuration ``y <-- x --> z``
+        with `1 \leq y < x < z \leq n`.
+
+        This condition is invariant under complementation.
+
+        EXAMPLES::
+
+            sage: len([T for T in TamariIntervalPosets(3)
+            ....:     if T.is_exceptional()])
+            12
+        """
+        G = self.poset().hasse_diagram()
+        for x in G:
+            nx = G.neighbors_out(x)
+            nx.append(x)
+            if min(nx) < x < max(nx):
+                return False
+        return True
+
+    def is_dexter(self) -> bool:
+        r"""
+        Return whether ``self`` is a dexter Tamari interval.
+
+        This is defined by an exclusion pattern in the Hasse diagram.
+        See the code for the exact description.
+
+        This condition is not invariant under complementation.
+
+        EXAMPLES::
+
+            sage: len([T for T in TamariIntervalPosets(3) if T.is_dexter()])
+            12
+        """
+        G = self.poset().hasse_diagram()
+        n = self.size()
+        for x in range(2, n):
+            nx = G.neighbors_out(x)
+            nx.append(x)
+            y = min(nx)
+            if y < x and any(z > x for z in G.neighbor_out_iterator(y)):
+                return False
+        return True
+
+    def is_indecomposable(self) -> bool:
+        """
+        Return whether ``self`` is an indecomposable Tamari interval.
+
+        This is the terminology of [Cha2008]_.
+
+        This means that the upper binary tree has an empty left subtree.
+
+        This condition is not invariant under complementation.
+
+        .. SEEALSO:: :meth:`is_connected`
+
+        EXAMPLES::
+
+            sage: len([T for T in TamariIntervalPosets(3)
+            ....:      if T.is_indecomposable()])
+            8
+        """
+        return not self.upper_binary_tree()[0]
+
+    def is_connected(self) -> bool:
+        """
+        Return whether ``self`` is a connected Tamari interval.
+
+        This means that the Hasse diagram is connected.
+
+        This condition is invariant under complementation.
+
+        .. SEEALSO:: :meth:`is_indecomposable`, :meth:`factor`
+
+        EXAMPLES::
+
+            sage: len([T for T in TamariIntervalPosets(3) if T.is_connected()])
+            8
+        """
+        return self.poset().is_connected()
+
+
+# Abstract class to serve as a Factory ; no instances are created.
+class TamariIntervalPosets(UniqueRepresentation, Parent):
+    r"""
+    Factory for interval-posets.
+
+    INPUT:
+
+    - ``size`` -- integer (optional)
+
+    OUTPUT:
+
+    - the set of all interval-posets (of the given ``size`` if specified)
+
+    EXAMPLES::
+
+        sage: TamariIntervalPosets()
+        Interval-posets
+
+        sage: TamariIntervalPosets(2)
+        Interval-posets of size 2
+
+    .. NOTE::
+
+        This is a factory class whose constructor returns instances of
+        subclasses.
+    """
+    @staticmethod
+    def __classcall_private__(cls, n=None):
+        r"""
+        TESTS::
+
+            sage: from sage.combinat.interval_posets import TamariIntervalPosets_all, TamariIntervalPosets_size
+            sage: isinstance(TamariIntervalPosets(2), TamariIntervalPosets_size)
+            True
+            sage: isinstance(TamariIntervalPosets(), TamariIntervalPosets_all)
+            True
+            sage: TamariIntervalPosets(2) is TamariIntervalPosets_size(2)
+            True
+            sage: TamariIntervalPosets() is TamariIntervalPosets_all()
+            True
+
+            sage: TamariIntervalPosets(-2)
+            Traceback (most recent call last):
+            ...
+            ValueError: n must be a nonnegative integer
+        """
+        if n is None:
+            return TamariIntervalPosets_all()
+
+        if n not in NN:
+            raise ValueError("n must be a nonnegative integer")
+        return TamariIntervalPosets_size(Integer(n))
+
+    # add options to class
+    class options(GlobalOptions):
+        r"""
+        Set and display the options for Tamari interval-posets.
+
+        If no parameters are set, then the function returns a copy of
+        the options dictionary.
+
+        The ``options`` to Tamari interval-posets can be accessed as the method
+        :meth:`TamariIntervalPosets.options` of :class:`TamariIntervalPosets`
+        and related parent classes.
+
+        @OPTIONS@
+
+        EXAMPLES::
+
+            sage: TIP = TamariIntervalPosets
+            sage: TIP.options.latex_color_decreasing
+            red
+            sage: TIP.options.latex_color_decreasing = 'green'
+            sage: TIP.options.latex_color_decreasing
+            green
+            sage: TIP.options._reset()
+            sage: TIP.options.latex_color_decreasing
+            red
+        """
+        NAME = 'TamariIntervalPosets'
+        module = 'sage.combinat.interval_posets'
+        latex_tikz_scale = dict(default=1,
+                              description='the default value for the tikz scale when latexed',
+                              checker=lambda x: True)  # More trouble than it's worth to check
+        latex_line_width_scalar = dict(default=0.5,
+                                     description='the default value for the line width as a'
+                                                 'multiple of the tikz scale when latexed',
+                                     checker=lambda x: True)  # More trouble than it's worth to check
+        latex_color_decreasing = dict(default='red',
+                                    description='the default color of decreasing relations when latexed',
+                                    checker=lambda x: True)  # More trouble than it's worth to check
+        latex_color_increasing = dict(default='blue',
+                                    description='the default color of increasing relations when latexed',
+                                    checker=lambda x: True)  # More trouble than it's worth to check
+        latex_hspace = dict(default=1,
+                          description='the default difference between horizontal'
+                                      ' coordinates of vertices when latexed',
+                          checker=lambda x: True)  # More trouble than it's worth to check
+        latex_vspace = dict(default=1,
+                          description='the default difference between vertical'
+                                      ' coordinates of vertices when latexed',
+                          checker=lambda x: True)   # More trouble than it's worth to check
+
+    @staticmethod
+    def check_poset(poset) -> bool:
+        r"""
+        Check if the given poset ``poset`` is a interval-poset, that is,
+        if it satisfies the following properties:
+
+        - Its labels are exactly `1, \ldots, n` where `n` is its size.
+        - If `a < c` (as numbers) and `a` precedes `c`, then `b` precedes
+          `c` for all `b` such that `a < b < c`.
+        - If `a < c` (as numbers) and `c` precedes `a`, then `b` precedes
+          `a` for all `b` such that `a < b < c`.
+
+        INPUT:
+
+        - ``poset`` -- a finite labeled poset
+
+        EXAMPLES::
+
+            sage: p = Poset(([1,2,3],[(1,2),(3,2)]))
+            sage: TamariIntervalPosets.check_poset(p)
+            True
+            sage: p = Poset(([2,3],[(3,2)]))
+            sage: TamariIntervalPosets.check_poset(p)
+            False
+            sage: p = Poset(([1,2,3],[(3,1)]))
+            sage: TamariIntervalPosets.check_poset(p)
+            False
+            sage: p = Poset(([1,2,3],[(1,3)]))
+            sage: TamariIntervalPosets.check_poset(p)
+            False
+        """
+        if not set(poset._elements) == set(range(1, poset.cardinality() + 1)):
+            return False
+
+        for i in range(1, poset.cardinality() + 1):
+            stop = False
+            for j in range(i - 1, 0, -1):
+                if not poset.le(j, i):
+                    stop = True  # j does not precede i so no j'<j should
+                elif stop:
+                    return False
+            stop = False
+            for j in range(i + 1, poset.cardinality() + 1):
+                if not poset.le(j, i):
+                    stop = True  # j does not precede i so no j'>j should
+                elif stop:
+                    return False
+        return True
+
+    @staticmethod
+    def final_forest(element) -> TIP:
+        r"""
+        Return the final forest of a binary tree, an interval-poset or a
+        Dyck word.
+
+        A final forest is an interval-poset corresponding to a final
+        interval of the Tamari lattice, i.e., containing only decreasing
+        relations.
+
+        It can be constructed from a binary tree by its binary
+        search tree labeling with the rule: `b` precedes
+        `a` in the final forest iff `b` is in the right subtree of `a`
+        in the binary search tree.
+
+        INPUT:
+
+        - ``element`` -- a binary tree, a Dyck word or an interval-poset
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: TamariIntervalPosets.final_forest(ip)
+            The Tamari interval of size 4 induced by relations [(4, 3)]
+
+        From binary trees::
+
+            sage: bt = BinaryTree(); bt
+            .
+            sage: TamariIntervalPosets.final_forest(bt)
+            The Tamari interval of size 0 induced by relations []
+            sage: bt = BinaryTree([]); bt
+            [., .]
+            sage: TamariIntervalPosets.final_forest(bt)
+            The Tamari interval of size 1 induced by relations []
+            sage: bt = BinaryTree([[],None]); bt
+            [[., .], .]
+            sage: TamariIntervalPosets.final_forest(bt)
+            The Tamari interval of size 2 induced by relations []
+            sage: bt = BinaryTree([None,[]]); bt
+            [., [., .]]
+            sage: TamariIntervalPosets.final_forest(bt)
+            The Tamari interval of size 2 induced by relations [(2, 1)]
+            sage: bt = BinaryTree([[],[]]); bt
+            [[., .], [., .]]
+            sage: TamariIntervalPosets.final_forest(bt)
+            The Tamari interval of size 3 induced by relations [(3, 2)]
+            sage: bt = BinaryTree([[None,[[],None]],[]]); bt
+            [[., [[., .], .]], [., .]]
+            sage: TamariIntervalPosets.final_forest(bt)
+            The Tamari interval of size 5 induced by relations [(5, 4), (3, 1), (2, 1)]
+
+        From Dyck words::
+
+            sage: # needs sage.combinat
+            sage: dw = DyckWord([1,0])
+            sage: TamariIntervalPosets.final_forest(dw)
+            The Tamari interval of size 1 induced by relations []
+            sage: dw = DyckWord([1,1,0,1,0,0,1,1,0,0])
+            sage: TamariIntervalPosets.final_forest(dw)
+            The Tamari interval of size 5 induced by relations [(5, 4), (3, 1), (2, 1)]
+
+        TESTS::
+
+            sage: TamariIntervalPosets.final_forest('mont')
+            Traceback (most recent call last):
+            ...
+            ValueError: do not know how to construct the final forest of mont
+        """
+        if isinstance(element, TamariIntervalPoset):
+            return element.final_forest()
+
+        try:
+            DW = DyckWords()
+        except ImportError:
+            DW = ()
+
+        if element in DW:
+            binary_tree = element.to_binary_tree_tamari()
+        elif element in BinaryTrees() or element in LabelledBinaryTrees():
+            binary_tree = element
+        else:
+            raise ValueError(f"do not know how to construct the final forest of {element}")
+
+        def get_relations(bt, start=1):
+            r"""
+            Recursive method to get the binary tree final forest relations
+            with only one recursive reading of the tree.
+
+            The vertices are being labelled with integers starting with
+            ``start``.
+
+            OUTPUT:
+
+            - the indices of the nodes on the left border of the tree
+              (these become the roots of the forest)
+            - the relations of the final forest (as a list of tuples)
+            - the next available index for a node (size of tree +
+              ``start``)
+            """
+            if not bt:
+                return [], [], start  # leaf
+            roots, relations, index = get_relations(bt[0], start=start)
+            rroots, rrelations, rindex = get_relations(bt[1], start=index + 1)
+            roots.append(index)
+            relations.extend(rrelations)
+            relations.extend((j, index) for j in rroots)
+            return roots, relations, rindex
+
+        _, relations, index = get_relations(binary_tree)
+        P = FinitePoset(DiGraph([list(range(1, index)), relations],
+                                format='vertices_and_edges'))  # type:ignore
+        return TamariIntervalPoset(P, check=False)  # type:ignore
+
+    @staticmethod
+    def initial_forest(element) -> TIP:
+        r"""
+        Return the initial forest of a binary tree, an interval-poset or
+        a Dyck word.
+
+        An initial forest is an interval-poset corresponding to an initial
+        interval of the Tamari lattice, i.e., containing only increasing
+        relations.
+
+        It can be constructed from a binary tree by its binary
+        search tree labeling with the rule: `a` precedes `b` in the
+        initial forest iff `a` is in the left subtree of `b` in the
+        binary search tree.
+
+        INPUT:
+
+        - ``element`` -- a binary tree, a Dyck word or an interval-poset
+
+        EXAMPLES::
+
+            sage: ip = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: TamariIntervalPosets.initial_forest(ip)
+            The Tamari interval of size 4 induced by relations [(1, 2), (2, 3)]
+
+        with binary trees::
+
+            sage: bt = BinaryTree(); bt
+            .
+            sage: TamariIntervalPosets.initial_forest(bt)
+            The Tamari interval of size 0 induced by relations []
+            sage: bt = BinaryTree([]); bt
+            [., .]
+            sage: TamariIntervalPosets.initial_forest(bt)
+            The Tamari interval of size 1 induced by relations []
+            sage: bt = BinaryTree([[],None]); bt
+            [[., .], .]
+            sage: TamariIntervalPosets.initial_forest(bt)
+            The Tamari interval of size 2 induced by relations [(1, 2)]
+            sage: bt = BinaryTree([None,[]]); bt
+            [., [., .]]
+            sage: TamariIntervalPosets.initial_forest(bt)
+            The Tamari interval of size 2 induced by relations []
+            sage: bt = BinaryTree([[],[]]); bt
+            [[., .], [., .]]
+            sage: TamariIntervalPosets.initial_forest(bt)
+            The Tamari interval of size 3 induced by relations [(1, 2)]
+            sage: bt = BinaryTree([[None,[[],None]],[]]); bt
+            [[., [[., .], .]], [., .]]
+            sage: TamariIntervalPosets.initial_forest(bt)
+            The Tamari interval of size 5 induced by relations [(1, 4), (2, 3), (3, 4)]
+
+        from Dyck words::
+
+            sage: # needs sage.combinat
+            sage: dw = DyckWord([1,0])
+            sage: TamariIntervalPosets.initial_forest(dw)
+            The Tamari interval of size 1 induced by relations []
+            sage: dw = DyckWord([1,1,0,1,0,0,1,1,0,0])
+            sage: TamariIntervalPosets.initial_forest(dw)
+            The Tamari interval of size 5 induced by relations [(1, 4), (2, 3), (3, 4)]
+
+        TESTS::
+
+            sage: TamariIntervalPosets.initial_forest('mont')
+            Traceback (most recent call last):
+            ...
+            ValueError: do not know how to construct the initial forest of mont
+        """
+        if isinstance(element, TamariIntervalPoset):
+            return element.initial_forest()
+
+        try:
+            DW = DyckWords()
+        except ImportError:
+            DW = ()
+
+        if element in DW:
+            binary_tree = element.to_binary_tree_tamari()
+        elif element in BinaryTrees() or element in LabelledBinaryTrees():
+            binary_tree = element
+        else:
+            raise ValueError(f"do not know how to construct the initial forest of {element}")
+
+        def get_relations(bt, start=1):
+            r"""
+            Recursive method to get the binary tree initial forest
+            relations with only one recursive reading of the tree.
+
+            The vertices are being labelled with integers starting with
+            ``start``.
+
+            OUTPUT:
+
+            - the indices of the nodes on the right border of the tree
+              (these become the roots of the forest)
+            - the relations of the initial forest (as a list of tuples)
+            - the next available index for a node (size of tree +
+              ``start``)
+            """
+            if not bt:
+                return [], [], start  # leaf
+            lroots, lrelations, index = get_relations(bt[0], start=start)
+            roots, relations, rindex = get_relations(bt[1], start=index + 1)
+            roots.append(index)
+            relations.extend(lrelations)
+            relations.extend((j, index) for j in lroots)
+            return roots, relations, rindex
+
+        _, relations, index = get_relations(binary_tree)
+        P = FinitePoset(DiGraph([list(range(1, index)), relations],
+                                format='vertices_and_edges'))  # type:ignore
+        return TamariIntervalPoset(P, check=False)  # type:ignore
+
+    @staticmethod
+    def from_binary_trees(tree1, tree2) -> TIP:
+        r"""
+        Return the interval-poset corresponding to the interval
+        [``tree1``, ``tree2``] of the Tamari lattice.
+
+        Raise an exception if
+        ``tree1`` is not `\leq` ``tree2`` in the Tamari lattice.
+
+        INPUT:
+
+        - ``tree1`` -- a binary tree
+        - ``tree2`` -- a binary tree greater or equal than ``tree1`` for
+          the Tamari lattice
+
+        EXAMPLES::
+
+            sage: tree1 = BinaryTree([[],None])
+            sage: tree2 = BinaryTree([None,[]])
+            sage: TamariIntervalPosets.from_binary_trees(tree1,tree2)
+            The Tamari interval of size 2 induced by relations []
+            sage: TamariIntervalPosets.from_binary_trees(tree1,tree1)
+            The Tamari interval of size 2 induced by relations [(1, 2)]
+            sage: TamariIntervalPosets.from_binary_trees(tree2,tree2)
+            The Tamari interval of size 2 induced by relations [(2, 1)]
+
+            sage: tree1 = BinaryTree([[],[[None,[]],[]]])
+            sage: tree2 = BinaryTree([None,[None,[None,[[],[]]]]])
+            sage: TamariIntervalPosets.from_binary_trees(tree1,tree2)
+            The Tamari interval of size 6 induced by relations
+             [(4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+
+            sage: tree3 = BinaryTree([None,[None,[[],[None,[]]]]])
+            sage: TamariIntervalPosets.from_binary_trees(tree1,tree3)
+            Traceback (most recent call last):
+            ...
+            ValueError: the two binary trees are not comparable on the Tamari lattice
+            sage: TamariIntervalPosets.from_binary_trees(tree1,BinaryTree())
+            Traceback (most recent call last):
+            ...
+            ValueError: the two binary trees are not comparable on the Tamari lattice
+        """
+        initial_forest = TamariIntervalPosets.initial_forest(tree2)
+        final_forest = TamariIntervalPosets.final_forest(tree1)
+        try:
+            return initial_forest.intersection(final_forest)
+        except ValueError:
+            raise ValueError("the two binary trees are not comparable on the Tamari lattice")
+
+    @staticmethod
+    def from_dyck_words(dw1, dw2) -> TIP:
+        r"""
+        Return the interval-poset corresponding to the interval
+        [``dw1``, ``dw2``] of the Tamari lattice.
+
+        Raise an exception if the
+        two Dyck words ``dw1`` and ``dw2`` do not satisfy
+        ``dw1`` `\leq` ``dw2`` in the Tamari lattice.
+
+        INPUT:
+
+        - ``dw1`` -- a Dyck word
+        - ``dw2`` -- a Dyck word greater or equal than ``dw1`` for
+          the Tamari lattice
+
+        EXAMPLES::
+
+            sage: # needs sage.combinat
+            sage: dw1 = DyckWord([1,0,1,0])
+            sage: dw2 = DyckWord([1,1,0,0])
+            sage: TamariIntervalPosets.from_dyck_words(dw1, dw2)
+            The Tamari interval of size 2 induced by relations []
+            sage: TamariIntervalPosets.from_dyck_words(dw1,dw1)
+            The Tamari interval of size 2 induced by relations [(1, 2)]
+            sage: TamariIntervalPosets.from_dyck_words(dw2,dw2)
+            The Tamari interval of size 2 induced by relations [(2, 1)]
+
+            sage: # needs sage.combinat
+            sage: dw1 = DyckWord([1,0,1,1,1,0,0,1,1,0,0,0])
+            sage: dw2 = DyckWord([1,1,1,1,0,1,1,0,0,0,0,0])
+            sage: TamariIntervalPosets.from_dyck_words(dw1,dw2)
+            The Tamari interval of size 6 induced by relations
+             [(4, 5), (6, 5), (5, 2), (4, 3), (3, 2)]
+            sage: dw3 = DyckWord([1,1,1,0,1,1,1,0,0,0,0,0])
+            sage: TamariIntervalPosets.from_dyck_words(dw1,dw3)
+            Traceback (most recent call last):
+            ...
+            ValueError: the two Dyck words are not comparable on the Tamari lattice
+            sage: TamariIntervalPosets.from_dyck_words(dw1,DyckWord([1,0]))
+            Traceback (most recent call last):
+            ...
+            ValueError: the two Dyck words are not comparable on the Tamari lattice
+        """
+        tree1 = dw1.to_binary_tree_tamari()
+        tree2 = dw2.to_binary_tree_tamari()
+        try:
+            return TamariIntervalPosets.from_binary_trees(tree1, tree2)
+        except ValueError:
+            raise ValueError("the two Dyck words are not comparable on the Tamari lattice")
+
+    @staticmethod
+    def recomposition_from_triple(left: TIP, right: TIP, r) -> TIP:
+        """
+        Recompose an interval-poset from a triple (``left``, ``right``, ``r``).
+
+        For the inverse method,
+        see :meth:`TamariIntervalPoset.decomposition_to_triple`.
+
+        INPUT:
+
+        - ``left`` -- an interval-poset
+        - ``right`` -- an interval-poset
+        - ``r`` -- the parameter of the decomposition, an integer
+
+        OUTPUT: an interval-poset
+
+        EXAMPLES::
+
+            sage: T1 = TamariIntervalPoset(3, [(1, 2), (3, 2)])
+            sage: T2 = TamariIntervalPoset(4, [(2, 3), (4, 3)])
+            sage: TamariIntervalPosets.recomposition_from_triple(T1, T2, 2)
+            The Tamari interval of size 8 induced by relations [(1, 2), (2, 4),
+            (3, 4), (6, 7), (8, 7), (6, 4), (5, 4), (3, 2)]
+
+        REFERENCES:
+
+        - [Pons2018]_
+        """
+        root = left.size() + 1
+        rel = left.poset().cover_relations()
+        rel.extend((i, root) for i in left)
+        rel.extend((root + a, root + b)
+                   for a, b in right.poset().cover_relations())
+        decroot = right.decreasing_roots()[:r]
+        rel.extend((root + i, root) for i in decroot)
+        # does this describe only cover relations ?
+        # if yes, create the poset here and pass it as argument
+        return TamariIntervalPoset(left.size() + right.size() + 1, rel)
+
+    @staticmethod
+    def from_grafting_tree(tree) -> TIP:
+        """
+        Return an interval-poset from a grafting tree.
+
+        For the inverse method,
+        see :meth:`TamariIntervalPoset.grafting_tree`.
+
+        EXAMPLES::
+
+            sage: tip = TamariIntervalPoset(8, [(1,2), (2,4), (3,4), (6,7), (3,2), (5,4), (6,4), (8,7)])
+            sage: t = tip.grafting_tree()
+            sage: TamariIntervalPosets.from_grafting_tree(t) == tip
+            True
+
+        REFERENCES:
+
+        - [Pons2018]_
+        """
+        if tree.is_empty():
+            return TamariIntervalPoset(0, [])
+        r = tree.label()
+        left = TamariIntervalPosets.from_grafting_tree(tree[0])
+        right = TamariIntervalPosets.from_grafting_tree(tree[1])
+        return TamariIntervalPosets.recomposition_from_triple(left, right, r)
+
+    @staticmethod
+    def from_minimal_schnyder_wood(graph) -> TIP:
+        """
+        Return a Tamari interval built from a minimal Schnyder wood.
+
+        This is an implementation of Bernardi and Bonichon's bijection
+        [BeBo2009]_.
+
+        INPUT:
+
+        - ``graph`` -- a minimal Schnyder wood, given as a graph with colored
+          and oriented edges, without the three exterior unoriented edges
+
+        The three boundary vertices must be -1, -2 and -3.
+
+        One assumes moreover that the embedding around -1 is the
+        list of neighbors of -1 and not just a cyclic permutation of that.
+
+        Beware that the embedding convention used here is the opposite of
+        the one used by the plot method.
+
+        OUTPUT: a Tamari interval-poset
+
+        EXAMPLES:
+
+        A small example::
+
+            sage: TIP = TamariIntervalPosets
+            sage: G = DiGraph([(0,-1,0),(0,-2,1),(0,-3,2)], format='list_of_edges')
+            sage: G.set_embedding({-1:[0],-2:[0],-3:[0],0:[-1,-2,-3]})
+            sage: TIP.from_minimal_schnyder_wood(G)                                     # needs sage.combinat
+            The Tamari interval of size 1 induced by relations []
+
+        An example from page 14 of [BeBo2009]_::
+
+            sage: c0 = [(0,-1),(1,0),(2,0),(4,3),(3,-1),(5,3)]
+            sage: c1 = [(5,-2),(3,-2),(4,5),(1,3),(2,3),(0,3)]
+            sage: c2 = [(0,-3),(1,-3),(3,-3),(4,-3),(5,-3),(2,1)]
+            sage: ed = [(u,v,0) for u,v in c0]
+            sage: ed += [(u,v,1) for u,v in c1]
+            sage: ed += [(u,v,2) for u,v in c2]
+            sage: G = DiGraph(ed, format='list_of_edges')
+            sage: embed = {-1:[3,0],-2:[5,3],-3:[0,1,3,4,5]}
+            sage: data_emb = [[3,2,1,-3,-1],[2,3,-3,0],[3,1,0]]
+            sage: data_emb += [[-2,5,4,-3,1,2,0,-1],[5,-3,3],[-2,-3,4,3]]
+            sage: for k in range(6):
+            ....:     embed[k] = data_emb[k]
+            sage: G.set_embedding(embed)
+            sage: TIP.from_minimal_schnyder_wood(G)                                     # needs sage.combinat
+            The Tamari interval of size 6 induced by relations
+             [(1, 4), (2, 4), (3, 4), (5, 6), (6, 4), (5, 4), (3, 1), (2, 1)]
+
+        An example from page 18 of [BeBo2009]_::
+
+            sage: c0 = [(0,-1),(1,0),(2,-1),(3,2),(4,2),(5,-1)]
+            sage: c1 = [(5,-2),(2,-2),(4,-2),(3,4),(1,2),(0,2)]
+            sage: c2 = [(0,-3),(1,-3),(3,-3),(4,-3),(2,-3),(5,2)]
+            sage: ed = [(u,v,0) for u,v in c0]
+            sage: ed += [(u,v,1) for u,v in c1]
+            sage: ed += [(u,v,2) for u,v in c2]
+            sage: G = DiGraph(ed, format='list_of_edges')
+            sage: embed = {-1:[5,2,0],-2:[4,2,5],-3:[0,1,2,3,4]}
+            sage: data_emb = [[2,1,-3,-1],[2,-3,0],[3,-3,1,0,-1,5,-2,4]]
+            sage: data_emb += [[4,-3,2],[-2,-3,3,2],[-2,2,-1]]
+            sage: for k in range(6):
+            ....:     embed[k] = data_emb[k]
+            sage: G.set_embedding(embed)
+            sage: TIP.from_minimal_schnyder_wood(G)                                     # needs sage.combinat
+            The Tamari interval of size 6 induced by relations
+             [(1, 3), (2, 3), (4, 5), (5, 3), (4, 3), (2, 1)]
+
+        Another small example::
+
+            sage: c0 = [(0,-1),(2,-1),(1,0)]
+            sage: c1 = [(2,-2),(1,-2),(0,2)]
+            sage: c2 = [(0,-3),(1,-3),(2,1)]
+            sage: ed = [(u,v,0) for u,v in c0]
+            sage: ed += [(u,v,1) for u,v in c1]
+            sage: ed += [(u,v,2) for u,v in c2]
+            sage: G = DiGraph(ed, format='list_of_edges')
+            sage: embed = {-1:[2,0],-2:[1,2],-3:[0,1]}
+            sage: data_emb = [[2,1,-3,-1],[-3,0,2,-2],[-2,1,0,-1]]
+            sage: for k in range(3):
+            ....:     embed[k] = data_emb[k]
+            sage: G.set_embedding(embed)
+            sage: TIP.from_minimal_schnyder_wood(G)                                     # needs sage.combinat
+            The Tamari interval of size 3 induced by relations [(2, 3), (2, 1)]
+        """
+        from sage.combinat.dyck_word import DyckWord
+        color_a = graph.incoming_edges(-1)[0][2]
+        color_b = graph.incoming_edges(-2)[0][2]
+
+        embedding = graph.get_embedding()
+        graph0 = DiGraph([e for e in graph.edges(sort=False)
+                          if e[2] == color_a],
+                         format='list_of_edges')
+        restricted_embedding = {u: [v for v in embedding[u]
+                                    if v in graph0.neighbors_in(u) or
+                                    v in graph0.neighbors_out(u)]
+                                for u in graph0}
+
+        voisins_in = {}
+        for u in graph0:
+            if u != -1:
+                bad_emb = restricted_embedding[u]
+                sortie = graph0.neighbors_out(u)[0]
+                idx = bad_emb.index(sortie)
+                restricted_embedding[u] = bad_emb[idx:] + bad_emb[:idx]
+                voisins_in[u] = restricted_embedding[u][1:]
+            else:
+                voisins_in[u] = list(restricted_embedding[u])
+            voisins_in[u].reverse()  # To have them in the right order
+
+        graph0.set_embedding(restricted_embedding)
+
+        def clockwise_labelling(gr, vertex):
+            if len(gr) == 1:
+                return [vertex]
+            lbl = [vertex]
+            for w in voisins_in[vertex]:
+                lbl += clockwise_labelling(gr, w)
+            return lbl
+
+        def profil(gr, vertex):
+            if len(gr) == 1:
+                return []
+            lbl = []
+            for w in voisins_in[vertex]:
+                lbl += [1] + profil(gr, w) + [0]
+            return lbl
+
+        dyckword_bottom = profil(graph0, -1)
+        # this is the profile of the planar graph graph0
+
+        liste = clockwise_labelling(graph0, -1)[1:]
+        relabelling = {l: i for i, l in enumerate(liste)}
+        relabelling.update((i, i) for i in [-1, -2, -3])
+        new_graph = graph.relabel(relabelling, inplace=False)
+
+        dyckword_top = []
+        for i in range(1, len(graph) - 3):
+            indegree1 = len([u for u in new_graph.incoming_edges(i)
+                             if u[2] == color_b])
+            dyckword_top += [1] + [0] * indegree1
+        indegree1 = len([u for u in new_graph.incoming_edges(-2)
+                         if u[2] == color_b])
+        dyckword_top += [1] + [0] * indegree1
+
+        dyckword_bottom = DyckWord(dyckword_bottom)  # type:ignore
+        dyckword_top = DyckWord(dyckword_top)  # type:ignore
+        tip = TamariIntervalPosets(len(dyckword_bottom) // 2)
+        return tip.from_dyck_words(dyckword_bottom, dyckword_top)
+
+    def __call__(self, *args, **keywords):
+        r"""
+        Allow for a poset to be directly transformed into an interval-poset.
+
+        It is some kind of coercion but cannot be made through the coercion
+        system because posets do not have parents.
+
+        EXAMPLES::
+
+            sage: TIP = TamariIntervalPosets()
+            sage: p = Poset( ([1,2,3], [(1,2)]))
+            sage: TIP(p)
+            The Tamari interval of size 3 induced by relations [(1, 2)]
+            sage: TIP(TIP(p))
+            The Tamari interval of size 3 induced by relations [(1, 2)]
+            sage: TIP(3,[(1,2)])
+            The Tamari interval of size 3 induced by relations [(1, 2)]
+            sage: p = Poset(([1,2,3],[(1,3)]))
+            sage: TIP(p)
+            Traceback (most recent call last):
+            ...
+            ValueError: this does not satisfy the Tamari interval-poset condition
+        """
+        if isinstance(args[0], TamariIntervalPoset):
+            return args[0]
+        if len(args) == 1 and isinstance(args[0], FinitePoset):
+            return self.element_class(self, args[0])
+
+        return super().__call__(*args, **keywords)
+
+    def le(self, el1, el2) -> bool:
+        r"""
+        Poset structure on the set of interval-posets.
+
+        The comparison is first by size, then using the
+        cubical coordinates.
+
+        .. SEEALSO:: :meth:`~TamariIntervalPoset.cubical_coordinates`
+
+        INPUT:
+
+        - ``el1`` -- an interval-poset
+        - ``el2`` -- an interval-poset
+
+        EXAMPLES::
+
+            sage: ip1 = TamariIntervalPoset(4,[(1,2),(2,3),(4,3)])
+            sage: ip2 = TamariIntervalPoset(4,[(1,2),(2,3)])
+            sage: TamariIntervalPosets().le(ip1,ip2)
+            False
+            sage: TamariIntervalPosets().le(ip2,ip1)
+            True
+        """
+        cc1 = el1.cubical_coordinates()
+        cc2 = el2.cubical_coordinates()
+        return all(x1 <= x2 for x1, x2 in zip(cc1, cc2))
+
+#################################################################
+# Enumerated set of all Tamari Interval-posets
+#################################################################
+
+
+class TamariIntervalPosets_all(DisjointUnionEnumeratedSets, TamariIntervalPosets):
+    r"""
+    The enumerated set of all Tamari interval-posets.
+    """
+
+    def __init__(self):
+        r"""
+        TESTS::
+
+            sage: from sage.combinat.interval_posets import TamariIntervalPosets_all
+            sage: S = TamariIntervalPosets_all()
+            sage: S.cardinality()
+            +Infinity
+
+            sage: it = iter(S)
+            sage: [next(it) for i in range(5)]
+            [The Tamari interval of size 0 induced by relations [],
+             The Tamari interval of size 1 induced by relations [],
+             The Tamari interval of size 2 induced by relations [],
+             The Tamari interval of size 2 induced by relations [(2, 1)],
+             The Tamari interval of size 2 induced by relations [(1, 2)]]
+            sage: next(it).parent()
+            Interval-posets
+            sage: S(0,[])
+            The Tamari interval of size 0 induced by relations []
+
+            sage: S is TamariIntervalPosets_all()
+            True
+            sage: TestSuite(S).run()  # long time (7s)
+        """
+        DisjointUnionEnumeratedSets.__init__(
+            self, Family(NonNegativeIntegers(), TamariIntervalPosets_size),
+            facade=True, keepkey=False,
+            category=(Posets(), EnumeratedSets(), Monoids()))
+
+    def _repr_(self) -> str:
+        r"""
+        TESTS::
+
+            sage: TamariIntervalPosets()
+            Interval-posets
+        """
+        return "Interval-posets"
+
+    def one(self) -> TIP:
+        """
+        Return the unit of the monoid.
+
+        This is the empty interval poset, of size 0.
+
+        EXAMPLES::
+
+            sage: TamariIntervalPosets().one()
+            The Tamari interval of size 0 induced by relations []
+        """
+        return TamariIntervalPoset(0, [])
+
+    def _element_constructor_(self, size, relations) -> TIP:
+        r"""
+        EXAMPLES::
+
+            sage: TIP = TamariIntervalPosets()
+            sage: TIP(3,[(1,2)])
+            The Tamari interval of size 3 induced by relations [(1, 2)]
+        """
+        return self.element_class(self, size, relations)
+
+    def __contains__(self, x) -> bool:
+        r"""
+        TESTS::
+
+            sage: S = TamariIntervalPosets()
+            sage: 1 in S
+            False
+            sage: S(0,[]) in S
+            True
+        """
+        return isinstance(x, self.element_class)
+
+    Element = TamariIntervalPoset
+
+
+TIP = TamariIntervalPoset
+
+
+#################################################################
+# Enumerated set of Tamari interval-posets of a given size
+#################################################################
+class TamariIntervalPosets_size(TamariIntervalPosets):
+    r"""
+    The enumerated set of interval-posets of a given size.
+    """
+
+    def __init__(self, size):
+        r"""
+        TESTS::
+
+            sage: S = TamariIntervalPosets(3)
+            sage: assert S is TamariIntervalPosets(3)
+            sage: for i in range(5): TestSuite(TamariIntervalPosets(i)).run()
+        """
+        # there is a natural order on interval-posets through inclusions
+        # that is why we use the FinitePosets category
+        super().__init__(category=(FinitePosets(), FiniteEnumeratedSets()))
+
+        self._size = size
+
+    def _repr_(self) -> str:
+        r"""
+        TESTS::
+
+            sage: TamariIntervalPosets(3)
+            Interval-posets of size 3
+        """
+        return f"Interval-posets of size {self._size}"
+
+    def __contains__(self, x) -> bool:
+        r"""
+        TESTS::
+
+            sage: S = TamariIntervalPosets(3)
+            sage: 1 in S
+            False
+            sage: S([]) in S
+            True
+        """
+        return isinstance(x, self.element_class) and x.size() == self._size
+
+    def cardinality(self) -> Integer:
+        r"""
+        The cardinality of ``self``. That is, the number of
+        interval-posets of size `n`.
+
+        The formula was given in [Cha2008]_:
+
+        .. MATH::
+
+            \frac{2(4n+1)!}{(n+1)!(3n+2)!}
+            = \frac{2}{n(n+1)} \binom{4n+1}{n-1}.
+
+        EXAMPLES::
+
+            sage: [TamariIntervalPosets(i).cardinality() for i in range(6)]
+            [1, 1, 3, 13, 68, 399]
+        """
+        n = self._size
+        if n == 0:
+            return ZZ.one()
+        return (2 * Integer(4 * n + 1).binomial(n - 1)) // (n * (n + 1))
+        # return Integer(2 * factorial(4*n+1)/(factorial(n+1)*factorial(3*n+2)))
+
+    def __iter__(self) -> Iterator[TIP]:
+        r"""
+        Recursive generation: we iterate through all interval-posets of
+        size ``size - 1`` and add all possible relations to the last
+        vertex.
+
+        This works thanks to the fact that the restriction of an
+        interval-poset of size `n` to the subset `\{1, 2, \ldots, k\}` for
+        a fixed `k \leq n` is an interval-poset.
+
+        TESTS::
+
+            sage: TIP1 = TamariIntervalPosets(1)
+            sage: list(TIP1)
+            [The Tamari interval of size 1 induced by relations []]
+            sage: TIP2 = TamariIntervalPosets(2)
+            sage: list(TIP2)
+            [The Tamari interval of size 2 induced by relations [],
+             The Tamari interval of size 2 induced by relations [(2, 1)],
+             The Tamari interval of size 2 induced by relations [(1, 2)]]
+            sage: TIP3 = TamariIntervalPosets(3)
+            sage: list(TIP3)
+            [The Tamari interval of size 3 induced by relations [],
+             The Tamari interval of size 3 induced by relations [(3, 2)],
+             The Tamari interval of size 3 induced by relations [(2, 3)],
+             The Tamari interval of size 3 induced by relations [(1, 3), (2, 3)],
+             The Tamari interval of size 3 induced by relations [(2, 1)],
+             The Tamari interval of size 3 induced by relations [(3, 2), (2, 1)],
+             The Tamari interval of size 3 induced by relations [(3, 1), (2, 1)],
+             The Tamari interval of size 3 induced by relations [(2, 3), (2, 1)],
+             The Tamari interval of size 3 induced by relations [(2, 3), (3, 1), (2, 1)],
+             The Tamari interval of size 3 induced by relations [(1, 3), (2, 3), (2, 1)],
+             The Tamari interval of size 3 induced by relations [(1, 2)],
+             The Tamari interval of size 3 induced by relations [(1, 2), (3, 2)],
+             The Tamari interval of size 3 induced by relations [(1, 2), (2, 3)]]
+            sage: all(len(list(TamariIntervalPosets(i)))==TamariIntervalPosets(i).cardinality() for i in range(6))
+            True
+        """
+        n = self._size
+        if n <= 1:
+            yield TamariIntervalPoset(n, [], check=False)
+            return
+
+        for tip in TamariIntervalPosets(n - 1):
+            new_tip = TamariIntervalPoset(n, tip._cover_relations, check=False)
+            yield new_tip  # we have added an extra vertex but no relations
+
+            # adding a decreasing relation n>>m2 with m2<n and no
+            # increasing relations
+            for m2 in range(n - 1, 0, -1):
+                if new_tip.le(n - 1, m2):
+                    yield TamariIntervalPoset(n, new_tip._cover_relations + ((n, m2),), check=False)
+
+            for m in range(n - 1, 0, -1):
+                # adding an increasing relation m>>n
+                if not new_tip.le(m, n):
+                    new_tip = TamariIntervalPoset(n, new_tip._cover_relations + ((m, n),), check=False)
+                    yield new_tip
+                else:
+                    continue
+
+                # further adding a decreasing relation n>>m2 with m2<m
+                for m2 in range(m - 1, 0, -1):
+                    if new_tip.le(n - 1, m2):
+                        yield TamariIntervalPoset(n, new_tip._cover_relations + ((n, m2),), check=False)
+
+    def random_element(self) -> TIP:
+        """
+        Return a random Tamari interval of fixed size.
+
+        This is obtained by first creating a random rooted
+        planar triangulation, then computing its unique
+        minimal Schnyder wood, then applying a bijection
+        of Bernardi and Bonichon [BeBo2009]_.
+
+        Because the random rooted planar triangulation is
+        chosen uniformly at random, the Tamari interval is
+        also chosen according to the uniform distribution.
+
+        EXAMPLES::
+
+            sage: # needs sage.combinat
+            sage: T = TamariIntervalPosets(4).random_element()
+            sage: T.parent()
+            Interval-posets
+            sage: u = T.lower_dyck_word(); u   # random
+            [1, 1, 0, 1, 0, 0, 1, 0]
+            sage: v = T.lower_dyck_word(); v   # random
+            [1, 1, 0, 1, 0, 0, 1, 0]
+            sage: len(u)
+            8
+        """
+        from sage.graphs.schnyder import minimal_schnyder_wood
+        from sage.graphs.generators.random import RandomTriangulation
+        n = self._size
+        tri = RandomTriangulation(n + 3)
+        tip = TamariIntervalPosets
+        schnyder = minimal_schnyder_wood(tri, root_edge=(-1, -2),
+                                         check=False)
+        return tip.from_minimal_schnyder_wood(schnyder)
+
+    @lazy_attribute
+    def _parent_for(self):
+        r"""
+        The parent of the element generated by ``self``.
+
+        TESTS::
+
+            sage: TIP3 = TamariIntervalPosets(3)
+            sage: TIP3._parent_for
+            Interval-posets
+        """
+        return TamariIntervalPosets_all()
+
+    # This is needed because this is a facade parent via DisjointUnionEnumeratedSets
+    @lazy_attribute
+    def element_class(self):
+        r"""
+        TESTS::
+
+            sage: S = TamariIntervalPosets(3)
+            sage: S.element_class
+            <class 'sage.combinat.interval_posets.TamariIntervalPosets_all_with_category.element_class'>
+            sage: S.first().__class__ == TamariIntervalPosets().first().__class__
+            True
+        """
+        return self._parent_for.element_class
+
+    def _element_constructor_(self, relations) -> TIP:
+        r"""
+        EXAMPLES::
+
+            sage: TIP3 = TamariIntervalPosets(3)
+            sage: TIP3([(1,2)])
+            The Tamari interval of size 3 induced by relations [(1, 2)]
+            sage: TIP3([(3,4)])
+            Traceback (most recent call last):
+            ...
+            ValueError: the relations do not correspond to the size of the poset
+        """
+        return self.element_class(self, self._size, relations)