Ticket #14498: 14498-qfold-dont-use.patch

File 14498-qfold-dont-use.patch, 118.8 KB (added by darij, 6 years ago)

qfold -- used (mostly by myself) for more comfortable viewing

  • sage/combinat/abstract_tree.py

    # HG changeset patch
    # User Jean-Baptiste Priez <jbp@kerios.fr>
    # Date 1373370155 -7200
    # Node ID 00d7a7c997b7907768cdb55d64d1e3d43b3c428c
    # Parent  05e23bb87cc82efba51ceabed6a75a1bfbd38c0b
    algorithms for trees and latex output
    * several traversal algorithms
    * some methods added for binary heap
    * * *
    trac #14498: some improvements on trees
    
    diff --git a/sage/combinat/abstract_tree.py b/sage/combinat/abstract_tree.py
    a b incoherent with the data structure. 
    6666from sage.structure.list_clone import ClonableArray
    6767from sage.rings.integer import Integer
    6868from sage.misc.misc_c import prod
     69###############################################################################
     70# # use to load tikz in the preamble (one for *view* and one for *notebook*)
     71from sage.misc.latex import latex
     72latex.add_package_to_preamble_if_available("tikz")
     73latex.add_to_mathjax_avoid_list("tikz")
     74###############################################################################
     75
    6976
    7077# Unfortunately Cython forbids multiple inheritance. Therefore, we do not
    7178# inherits from SageObject to be able to inherits from Element or a subclass
    class AbstractTree(object): 
    7784    There is no data structure defined here, as this class is meant to be
    7885    extended, not instantiated.
    7986
    80     .. rubric:: How should this class be extended ?
     87    .. rubric:: How should this class be extended?
    8188
    8289    A class extending :class:`AbstractTree
    8390    <sage.combinat.abstract_tree.AbstractTree>` should respect several
    class AbstractTree(object): 
    106113        sage: TestSuite(OrderedTree()).run()
    107114        sage: TestSuite(BinaryTree()).run()
    108115    """
     116    def pre_order_traversal_iter(self):
     117        r"""
     118        The depth-first pre-order traversal iterator.
     119
     120        This method iters each node following the depth-first pre-order
     121        traversal algorithm (recursive implementation).
     122
     123        For example, on the following binary tree `b`::
     124
     125            |   ___3____      |
     126            |  /        \     |
     127            | 1         _7_   |
     128            |  \       /   \  |
     129            |   2     5     8 |
     130            |        / \      |
     131            |       4   6     |
     132
     133        the ``depth-first pre-order traversal algorithm`` explores `b` in the
     134        following order of nodes: `3,1,2,7,5,4,6,8`.
     135
     136        The algorithm is::
     137
     138            manipulate the root,
     139            then explore each subtree (by the algorithm).
     140
     141        Another example::
     142
     143            |     __1____ |
     144            |    /  /   / |
     145            |   2  6   8_ |
     146            |   |  |  / / |
     147            |   3_ 7 9 10 |
     148            |  / /        |
     149            | 4 5         |
     150
     151        The algorithm explores this tree in the following order:
     152        `1,2,3,4,5,6,7,8,9,10`.
     153
     154        TESTS::
     155
     156            sage: b = BinaryTree([[None,[]],[[[],[]],[]]]).canonical_labelling()
     157            sage: ascii_art([b])
     158            [   ___3____      ]
     159            [  /        \     ]
     160            [ 1         _7_   ]
     161            [  \       /   \  ]
     162            [   2     5     8 ]
     163            [        / \      ]
     164            [       4   6     ]
     165            sage: [n.label() for n in b.pre_order_traversal_iter()]
     166            [3, 1, 2, 7, 5, 4, 6, 8]
     167            sage: t = OrderedTree([[[[],[]]],[[]],[[],[]]]).canonical_labelling()
     168            sage: ascii_art([t])
     169            [     __1____   ]
     170            [    /  /   /   ]
     171            [   2  6   8_   ]
     172            [   |  |  / /   ]
     173            [   3_ 7 9 10   ]
     174            [  / /          ]
     175            [ 4 5           ]
     176            sage: [n.label() for n in t.pre_order_traversal_iter()]
     177            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     178        """
     179        if self.is_empty():
     180            return
     181        yield self
     182        # TODO:: PYTHON 3
     183        # import itertools
     184        # yield from itertools.chain(map(
     185        #     lambda c: c.pre_order_traversal_iter(),
     186        #     self
     187        # ))
     188        for children in self:
     189            for node in children.pre_order_traversal_iter():
     190                yield node
     191
     192    def iterative_pre_order_traversal(self, action=None):
     193        r"""
     194        The depth-first pre-order traversal algorithm (iterative
     195        implementation).
     196
     197        INPUT:
     198
     199        - ``action`` -- (optional) a function which takes a node in input
     200          and does something during the exploration
     201
     202        .. SEEALSO::
     203
     204            - :meth:`~sage.combinat.abstract_tree.AbstractTree.pre_order_traversal_iter()`
     205            - :meth:`~sage.combinat.abstract_tree.AbstractTree.pre_order_traversal()`
     206
     207        TESTS::
     208
     209            sage: l = []
     210            sage: b = BinaryTree([[None,[]],[[[],[]],[]]]).canonical_labelling()
     211            sage: b
     212            3[1[., 2[., .]], 7[5[4[., .], 6[., .]], 8[., .]]]
     213            sage: b.iterative_pre_order_traversal(lambda node: l.append(node.label()))
     214            sage: l
     215            [3, 1, 2, 7, 5, 4, 6, 8]
     216            sage: t = OrderedTree([[[[],[]]],[[]],[[],[]]]).canonical_labelling()
     217            sage: t
     218            1[2[3[4[], 5[]]], 6[7[]], 8[9[], 10[]]]
     219            sage: l = []
     220            sage: t.iterative_pre_order_traversal(lambda node: l.append(node.label()))
     221            sage: l
     222            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     223            sage: l = []
     224            sage: BinaryTree().canonical_labelling().\
     225            ....:     pre_order_traversal(lambda node: l.append(node.label()))
     226            sage: l
     227            []
     228            sage: OrderedTree([]).canonical_labelling().\
     229            ....:     iterative_pre_order_traversal(lambda node: l.append(node.label()))
     230            sage: l
     231            [1]
     232        """
     233        if self.is_empty():
     234            return
     235        if action is None:
     236            action = lambda x: None
     237        stack = []
     238        stack.append(self)
     239        while len(stack) > 0:
     240            node = stack.pop()
     241            action(node)
     242            for i in range(len(node)):
     243                subtree = node[-i - 1]
     244                if not subtree.is_empty():
     245                    stack.append(subtree)
     246
     247    def pre_order_traversal(self, action=None):
     248        r"""
     249        The depth-first pre-order traversal algorithm (recursive
     250        implementation).
     251
     252        INPUT:
     253
     254        - ``action`` -- (optional) a function which takes a node in input
     255          and does something during the exploration
     256
     257        For example on the following binary tree `b`::
     258
     259            |   ___3____      |
     260            |  /        \     |
     261            | 1         _7_   |
     262            |  \       /   \  |
     263            |   2     5     8 |
     264            |        / \      |
     265            |       4   6     |
     266
     267        the ``depth-first pre-order traversal algorithm`` explores `b` in the
     268        following order of nodes `3,1,2,7,5,4,6,8`.
     269
     270        The algorithm is::
     271
     272            manipulate the root with function `action`,
     273            then explore each subtrees (by the algorithm)
     274
     275        Another example::
     276
     277            |     __1____ |
     278            |    /  /   / |
     279            |   2  6   8_ |
     280            |   |  |  / / |
     281            |   3_ 7 9 10 |
     282            |  / /        |
     283            | 4 5         |
     284
     285        The algorithm explores this tree in the following order:
     286        `1,2,3,4,5,6,7,8,9,10`.
     287
     288        .. SEEALSO::
     289
     290            - :meth:`~sage.combinat.abstract_tree.AbstractTree.pre_order_traversal_iter()`
     291            - :meth:`~sage.combinat.abstract_tree.AbstractTree.iterative_pre_order_traversal()`
     292
     293        TESTS::
     294
     295            sage: l = []
     296            sage: b = BinaryTree([[None,[]],[[[],[]],[]]]).canonical_labelling()
     297            sage: b
     298            3[1[., 2[., .]], 7[5[4[., .], 6[., .]], 8[., .]]]
     299            sage: b.pre_order_traversal(lambda node: l.append(node.label()))
     300            sage: l
     301            [3, 1, 2, 7, 5, 4, 6, 8]
     302            sage: li = []
     303            sage: b.iterative_pre_order_traversal(lambda node: li.append(node.label()))
     304            sage: l == li
     305            True
     306            sage: t = OrderedTree([[[[],[]]],[[]],[[],[]]]).canonical_labelling()
     307            sage: t
     308            1[2[3[4[], 5[]]], 6[7[]], 8[9[], 10[]]]
     309            sage: l = []
     310            sage: t.pre_order_traversal(lambda node: l.append(node.label()))
     311            sage: l
     312            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     313            sage: li = []
     314            sage: t.iterative_pre_order_traversal(lambda node: li.append(node.label()))
     315            sage: l == li
     316            True
     317            sage: l = []
     318            sage: BinaryTree().canonical_labelling().\
     319            ....:     pre_order_traversal(lambda node: l.append(node.label()))
     320            sage: l
     321            []
     322            sage: OrderedTree([]).canonical_labelling().\
     323            ....:     pre_order_traversal(lambda node: l.append(node.label()))
     324            sage: l
     325            [1]
     326        """
     327        if action is None:
     328            action = lambda x: None
     329        for node in self.pre_order_traversal_iter():
     330            action(node)
     331
     332    def post_order_traversal_iter(self):
     333        r"""
     334        The depth-first post-order traversal iterator.
     335
     336        This method iters each node following the depth-first post-order
     337        traversal algorithm (recursive implementation).
     338
     339        For example on the following binary tree `b`::
     340
     341            |   ___3____      |
     342            |  /        \     |
     343            | 1         _7_   |
     344            |  \       /   \  |
     345            |   2     5     8 |
     346            |        / \      |
     347            |       4   6     |
     348
     349        the ``depth-first post-order traversal algorithm`` explores `b` in the
     350        following order of nodes `2,1,4,6,5,8,7,3`.
     351
     352        The algorithm is::
     353
     354            explore each subtrees (by the algorithm)
     355            then manipulate the root with function `action`
     356
     357        Another example::
     358
     359            |     __1____ |
     360            |    /  /   / |
     361            |   2  6   8_ |
     362            |   |  |  / / |
     363            |   3_ 7 9 10 |
     364            |  / /        |
     365            | 4 5         |
     366
     367        The algorithm explores this tree in the following order:
     368        `4,5,3,2,7,6,9,10,8,1`.
     369
     370        TESTS::
     371
     372            sage: b = BinaryTree([[None,[]],[[[],[]],[]]]).canonical_labelling()
     373            sage: ascii_art([b])
     374            [   ___3____      ]
     375            [  /        \     ]
     376            [ 1         _7_   ]
     377            [  \       /   \  ]
     378            [   2     5     8 ]
     379            [        / \      ]
     380            [       4   6     ]
     381            sage: [node.label() for node in b.post_order_traversal_iter()]
     382            [2, 1, 4, 6, 5, 8, 7, 3]
     383            sage: t = OrderedTree([[[[],[]]],[[]],[[],[]]]).canonical_labelling()
     384            sage: ascii_art([t])
     385            [     __1____   ]
     386            [    /  /   /   ]
     387            [   2  6   8_   ]
     388            [   |  |  / /   ]
     389            [   3_ 7 9 10   ]
     390            [  / /          ]
     391            [ 4 5           ]
     392            sage: [node.label() for node in t.post_order_traversal_iter()]
     393            [4, 5, 3, 2, 7, 6, 9, 10, 8, 1]
     394            sage: [node.label() for node in BinaryTree().canonical_labelling().\
     395            ....:     post_order_traversal_iter()]
     396            []
     397            sage: [node.label() for node in OrderedTree([]).\
     398            ....:     canonical_labelling().post_order_traversal_iter()]
     399            [1]
     400        """
     401        if self.is_empty():
     402            return
     403        # TODO:: PYTHON 3
     404        # import itertools
     405        # yield from itertools.chain(map(
     406        #     lambda c: c.post_order_traversal_iter(),
     407        #     self
     408        # ))
     409        for children in self:
     410            for node in children.post_order_traversal_iter():
     411                yield node
     412        yield self
     413
     414    def post_order_traversal(self, action=None):
     415        r"""
     416        The depth-first post-order traversal algorithm (recursive
     417        implementation).
     418
     419        INPUT:
     420
     421        - ``action`` -- (optional) a function which takes a node in
     422          input and does something during the exploration
     423
     424        .. SEEALSO::
     425
     426            - :meth:`~sage.combinat.abstract_tree.AbstractTree.post_order_traversal_iter()`
     427            - :meth:`~sage.combinat.abstract_tree.AbstractTree.iterative_post_order_traversal()`
     428
     429        TESTS::
     430
     431            sage: l = []
     432            sage: b = BinaryTree([[None,[]],[[[],[]],[]]]).canonical_labelling()
     433            sage: b
     434            3[1[., 2[., .]], 7[5[4[., .], 6[., .]], 8[., .]]]
     435            sage: b.post_order_traversal(lambda node: l.append(node.label()))
     436            sage: l
     437            [2, 1, 4, 6, 5, 8, 7, 3]
     438            sage: t = OrderedTree([[[[],[]]],[[]],[[],[]]]).\
     439            ....:     canonical_labelling(); t
     440            1[2[3[4[], 5[]]], 6[7[]], 8[9[], 10[]]]
     441            sage: l = []
     442            sage: t.post_order_traversal(lambda node: l.append(node.label()))
     443            sage: l
     444            [4, 5, 3, 2, 7, 6, 9, 10, 8, 1]
     445            sage: l = []
     446            sage: BinaryTree().canonical_labelling().\
     447            ....:     post_order_traversal(lambda node: l.append(node.label()))
     448            sage: l
     449            []
     450            sage: OrderedTree([]).canonical_labelling().\
     451            ....:     post_order_traversal(lambda node: l.append(node.label()))
     452            sage: l
     453            [1]
     454        """
     455        if action is None:
     456            action = lambda x: None
     457        for node in self.post_order_traversal_iter():
     458            action(node)
     459
     460    def iterative_post_order_traversal(self, action=None):
     461        r"""
     462        The depth-first post-order traversal algorithm (iterative
     463        implementation).
     464
     465        INPUT:
     466
     467        - ``action`` -- (optional) a function which takes a node in input and
     468          does something during the exploration
     469
     470        .. SEEALSO::
     471
     472            - :meth:`~sage.combinat.abstract_tree.AbstractTree.post_order_traversal_iter()`
     473
     474        TESTS::
     475
     476            sage: l = []
     477            sage: b = BinaryTree([[None,[]],[[[],[]],[]]]).canonical_labelling()
     478            sage: b
     479            3[1[., 2[., .]], 7[5[4[., .], 6[., .]], 8[., .]]]
     480            sage: b.iterative_post_order_traversal(lambda node: l.append(node.label()))
     481            sage: l
     482            [8, 6, 4, 5, 7, 2, 1, 3]
     483            sage: t = OrderedTree([[[[],[]]],[[]],[[],[]]]).canonical_labelling()
     484            sage: t
     485            1[2[3[4[], 5[]]], 6[7[]], 8[9[], 10[]]]
     486            sage: l = []
     487            sage: t.iterative_post_order_traversal(lambda node: l.append(node.label()))
     488            sage: l
     489            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
     490            sage: l = []
     491            sage: BinaryTree().canonical_labelling().\
     492            ....:     iterative_post_order_traversal(
     493            ....:         lambda node: l.append(node.label()))
     494            sage: l
     495            []
     496            sage: OrderedTree([]).canonical_labelling().\
     497            ....:     iterative_post_order_traversal(
     498            ....:         lambda node: l.append(node.label()))
     499            sage: l
     500            [1]
     501        """
     502        if self.is_empty():
     503            return
     504        if action is None:
     505            action = lambda x: None
     506        stack = [self]
     507        mark = []
     508        while len(stack) > 0:
     509            node = stack[-1]
     510            if node in mark:
     511                stack.pop()
     512                action(node)
     513            else:
     514                mark.append(node)
     515                stack.extend(filter(lambda n: not n.is_empty(), node))
     516
     517    def breadth_first_order_traversal(self, action=None):
     518        r"""
     519        The breadth-first order traversal algorithm.
     520
     521        INPUT:
     522
     523        - ``action`` -- (optional) a function which takes a node in input and
     524          does omething during the exploration
     525
     526        For example, on the following binary tree `b`::
     527
     528            |   ___3____      |
     529            |  /        \     |
     530            | 1         _7_   |
     531            |  \       /   \  |
     532            |   2     5     8 |
     533            |        / \      |
     534            |       4   6     |
     535
     536        the ``breadth-first order traversal algorithm`` explores `b` in the
     537        following order of nodes: `3,1,7,2,5,8,4,6`.
     538
     539        The algorithm is::
     540
     541            queue <- ( root )
     542            while the queue is not empty:
     543                node <- pop( queue )
     544                manipulate the node
     545                append in the queue all subtrees of the node
     546
     547        TESTS::
     548
     549            sage: b = BinaryTree([[None,[]],[[[],[]],[]]]).canonical_labelling()
     550            sage: l = []
     551            sage: b.breadth_first_order_traversal(lambda node: l.append(node.label()))
     552            sage: l
     553            [3, 1, 7, 2, 5, 8, 4, 6]
     554            sage: t = OrderedTree([[[[],[]]],[[]],[[],[]]]).canonical_labelling()
     555            sage: t
     556            1[2[3[4[], 5[]]], 6[7[]], 8[9[], 10[]]]
     557            sage: l = []
     558            sage: t.breadth_first_order_traversal(lambda node: l.append(node.label()))
     559            sage: l
     560            [1, 2, 6, 8, 3, 7, 9, 10, 4, 5]
     561            sage: l = []
     562            sage: BinaryTree().canonical_labelling().\
     563            ....:     breadth_first_order_traversal(
     564            ....:         lambda node: l.append(node.label()))
     565            sage: l
     566            []
     567            sage: OrderedTree([]).canonical_labelling().\
     568            ....:     breadth_first_order_traversal(
     569            ....:         lambda node: l.append(node.label()))
     570            sage: l
     571            [1]
     572        """
     573        if self.is_empty():
     574            return
     575        if action is None:
     576            action = lambda x: None
     577        queue = []
     578        queue.append(self)
     579        while len(queue) > 0:
     580            node = queue.pop()
     581            action(node)
     582            for subtree in node:
     583                if not subtree.is_empty():
     584                    queue.insert(0, subtree)
    109585
    110586    def subtrees(self):
    111587        """
    112         Returns a generator for all subtrees of ``self``
     588        Return a generator for all subtrees of ``self``.
    113589
    114590        The number of subtrees of a tree is its number of elements.
    115591
    class AbstractTree(object): 
    134610            sage: bt.node_number() == len(list(bt.subtrees()))
    135611            True
    136612        """
    137         if not self.is_empty():
    138             yield self
    139             for i in self:
    140                 for t in i.subtrees():
    141                     yield t
     613        return self.pre_order_traversal_iter()
    142614
    143615    def paths(self):
    144616        """
    145         Returns a generator for all paths to nodes of ``self``
     617        Return a generator for all paths to nodes of ``self``.
    146618
    147619        OUTPUT:
    148620
    class AbstractTree(object): 
    387859
    388860    def tree_factorial(self):
    389861        """
    390         Returns the tree-factorial of ``self``
     862        Return the tree-factorial of ``self``
    391863
    392864        Definition:
    393865
    class AbstractTree(object): 
    412884        nb = self.node_number()
    413885        if nb <= 1:
    414886            return 1
    415         else:
    416             return nb*prod(s.tree_factorial() for s in self)
    417 
    418     latex_unit_length   = "4mm"
    419     latex_node_diameter = "0.5"
    420     latex_root_diameter = "0.7"
     887        return nb * prod(s.tree_factorial() for s in self)
    421888
    422889    def _latex_(self):
    423         """
    424         Returns a LaTeX version of ``self``
    425 
    426         EXAMPLES::
    427 
    428             sage: print(OrderedTree([[],[]])._latex_())
    429             \vcenter{\hbox{{\setlength\unitlength{4mm}
    430             \begin{picture}(4,3)
    431             \put(1,1){\circle*{0.5}}
    432             \put(2,2){\circle*{0.5}}
    433             \put(3,1){\circle*{0.5}}
    434             \put(2,2){\line(-1,-1){1}}
    435             \put(2,2){\line(1,-1){1}}
    436             \put(2,2){\circle*{0.7}}
    437             \end{picture}}}}
     890        r"""
     891        Nice output which can be easily modified
    438892
    439893        TESTS::
    440894
    441             sage: OrderedTree([])._latex_()
    442             '\\vcenter{\\hbox{{\\setlength\\unitlength{4mm}\n\\begin{picture}(2,2)\n\\put(1,1){\\circle*{0.5}}\n\\put(1,1){\\circle*{0.7}}\n\\end{picture}}}}'
    443             sage: OrderedTree([[]])._latex_()
    444             '\\vcenter{\\hbox{{\\setlength\\unitlength{4mm}\n\\begin{picture}(2,3)\n\\put(1,1){\\circle*{0.5}}\n\\put(1,2){\\circle*{0.5}}\n\\put(1,2){\\line(0,-1){1}}\n\\put(1,2){\\circle*{0.7}}\n\\end{picture}}}}'
    445             sage: OrderedTree([[], [[], [[], []], [[], []]], [[], []]])._latex_()
    446             '\\vcenter{\\hbox{{\\setlength\\unitlength{4mm}\n\\begin{picture}(12,5)\n\\put(1,3){\\circle*{0.5}}\n\\put(2,2){\\circle*{0.5}}\n\\put(3,1){\\circle*{0.5}}\n\\put(4,2){\\circle*{0.5}}\n\\put(5,1){\\circle*{0.5}}\n\\put(4,2){\\line(-1,-1){1}}\n\\put(4,2){\\line(1,-1){1}}\n\\put(4,3){\\circle*{0.5}}\n\\put(6,1){\\circle*{0.5}}\n\\put(7,2){\\circle*{0.5}}\n\\put(8,1){\\circle*{0.5}}\n\\put(7,2){\\line(-1,-1){1}}\n\\put(7,2){\\line(1,-1){1}}\n\\put(4,3){\\line(-2,-1){2}}\n\\put(4,3){\\line(0,-1){1}}\n\\put(4,3){\\line(3,-1){3}}\n\\put(4,4){\\circle*{0.5}}\n\\put(9,2){\\circle*{0.5}}\n\\put(10,3){\\circle*{0.5}}\n\\put(11,2){\\circle*{0.5}}\n\\put(10,3){\\line(-1,-1){1}}\n\\put(10,3){\\line(1,-1){1}}\n\\put(4,4){\\line(-3,-1){3}}\n\\put(4,4){\\line(0,-1){1}}\n\\put(4,4){\\line(6,-1){6}}\n\\put(4,4){\\circle*{0.7}}\n\\end{picture}}}}'
     895            sage: latex(BinaryTree([[[],[]],[[],None]]))
     896            { \newcommand{\nodea}{\node[draw,circle] (a) {$$}
     897            ;}\newcommand{\nodeb}{\node[draw,circle] (b) {$$}
     898            ;}\newcommand{\nodec}{\node[draw,circle] (c) {$$}
     899            ;}\newcommand{\noded}{\node[draw,circle] (d) {$$}
     900            ;}\newcommand{\nodee}{\node[draw,circle] (e) {$$}
     901            ;}\newcommand{\nodef}{\node[draw,circle] (f) {$$}
     902            ;}\begin{tikzpicture}[auto]
     903            \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     904                     \&         \&         \& \nodea  \&         \&         \&         \\
     905                     \& \nodeb  \&         \&         \&         \& \nodee  \&         \\
     906             \nodec  \&         \& \noded  \&         \& \nodef  \&         \&         \\
     907            };
     908            <BLANKLINE>
     909            \path[ultra thick, red] (b) edge (c) edge (d)
     910                (e) edge (f)
     911                (a) edge (b) edge (e);
     912            \end{tikzpicture}}
    447913        """
    448         from sage.misc.latex import latex
    449         drawing = [""] # allows modification of  in rec...
    450         x = [1]        # allows modification of x[0] in rec...
    451         max_label_width = [0] # allows modification of x[0] in rec...
    452         maxy = self.depth()
     914        # latex environnement : TikZ
     915        begin_env = "\\begin{tikzpicture}[auto]\n"
     916        end_env = "\\end{tikzpicture}"
     917        # it uses matrix trick to place each node
     918        matrix_begin = "\\matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{\n"
     919        matrix_end = "\\\\\n};\n"
     920        # a basic path to each edges
     921        path_begin = "\\path[ultra thick, red] "
     922        path_end = ";\n"
     923        # to make a pretty output, it creates one LaTeX command for
     924        # each node
     925        cmd = "\\node"
     926        new_cmd1 = "\\newcommand{" + cmd
     927        new_cmd2 = "}{\\node[draw,circle] ("
     928        new_cmd3 = ") {$"
     929        new_cmd4 = "$}\n;}"
     930        # some variables to simplify code
     931        sep = "\\&"
     932        space = " "*9
     933        sepspace = sep + space
     934        spacesep = space + sep
     935        node_to_str = lambda node: " " + node + " " * (len(space) - 1 - len(node))
     936        # # TODO:: modify how to create nodes --> new_cmd : \\node[...] in create_node
     937        num = [0]
    453938
    454         def rec(t, y):
    455             """
    456             Draw the subtree t on the drawing, below y (included) and to
    457             the right of x[0] (included). Update x[0]. Returns the horizontal
    458             position of the root
    459             """
    460             if t.node_number() == 0 : return -1
    461             n = len(t)
    462             posChild = [rec(t[i], y+1) for i in range(n // 2)]
    463             i = n // 2
    464             if n % 2 == 1:
    465                 xc = rec(t[i], y+1)
    466                 posChild.append(xc)
    467                 i += 1
     939        def resolve(self):
     940            nodes = []; matrix = []; edges = []
     941
     942            def create_node(self):
     943                r"""
     944                create a name (infixe reading)
     945                 -> ex: b
     946                create a new command:
     947                 -> ex: \newcommand{\nodeb}{\node[draw,circle] (b) {$$};
     948                return the name and the command to build:
     949                  . the matrix
     950                  . and the edges
     951                """
     952                name = reduce(
     953                    lambda x, y: x + y,
     954                    map(
     955                        lambda x: chr(ord(x) + 49),
     956                        list(str(num[0]))),
     957                    "")
     958                node = cmd + name
     959                nodes.append((name,
     960                    (str(self.label()) if hasattr(self, "label") else ""))
     961                )
     962                num[0] += 1
     963                return node, name
     964
     965            def empty_tree():
     966                r"""
     967                TESTS::
     968
     969                    sage: t = BinaryTree()
     970                    sage: print latex(t)
     971                    { \begin{tikzpicture}[auto]
     972                    \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     973                             \\
     974                    };
     975                    \end{tikzpicture}}
     976                """
     977                matrix.append(space)
     978
     979            def one_node_tree(self):
     980                r"""
     981                TESTS::
     982
     983                    sage: t = BinaryTree([]); print latex(t)
     984                    { \newcommand{\nodea}{\node[draw,circle] (a) {$$}
     985                    ;}\begin{tikzpicture}[auto]
     986                    \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     987                     \nodea  \\
     988                    };
     989                    \end{tikzpicture}}
     990                    sage: t = OrderedTree([]); print latex(t)
     991                    { \newcommand{\nodea}{\node[draw,circle] (a) {$$}
     992                    ;}\begin{tikzpicture}[auto]
     993                    \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     994                     \nodea  \\
     995                    };
     996                    \end{tikzpicture}}
     997                """
     998                node, _ = create_node(self)
     999                matrix.append(node_to_str(node))
     1000
     1001            def concat_matrix(mat, mat2):
     1002                lmat = len(mat); lmat2 = len(mat2)
     1003                for i in range(max(lmat, lmat2)):
     1004                    # mat[i] --> n & n & ...
     1005                    # mat2[i] -> n' & n' & ...
     1006                    # ==> n & n & ... & n' & n' & ...
     1007                    try:
     1008                        mat[i] += sep + mat2[i]
     1009                    except:
     1010                        if i >= lmat:
     1011                            if i != 0:
     1012                                # mat[i] doesn't exist but
     1013                                # mat[0] has k "&"
     1014                                # mat2[i] -> n' & n' & ...
     1015                                # ==> (_ &)*k+1 n' & n' & ...
     1016                                nb_of_and = mat[0].count(sep) - mat2[0].count(sep)
     1017                                mat.append(spacesep * (nb_of_and) + mat2[i])
     1018                            else:
     1019                                # mat is empty
     1020                                # mat2[i] -> n' & n' & ...
     1021                                # ==> mat2
     1022                                mat.extend(mat2)
     1023                                return
     1024                        else:
     1025                            # mat[i] -> n & n & ...
     1026                            # mat2[i] doesn't exist but mat2[0] exists
     1027                            # # and has k "&"
     1028                            # NOTE:: i != 0 because that is a no-empty subtree.
     1029                            # ==> n & n & ... (& _)*k+1
     1030                            nb_of_and = mat2[0].count(sep)
     1031                            mat[i] += sepspace * (nb_of_and + 1)
     1032
     1033            def tmp(subtree, edge, nodes, edges, matrix):
     1034                if not subtree.is_empty():
     1035                    # # create representation of the subtree
     1036                    nodes_st, matrix_st, edges_st = resolve(subtree)
     1037                    # # add its nodes to the "global" nodes set
     1038                    nodes.extend(nodes_st)
     1039                    # # create a new edge between the root and the subtree
     1040                    edge.append(nodes_st[0][0])
     1041                    # # add the subtree edges to the "global" edges set
     1042                    edges.extend(edges_st)
     1043                    # # build a new matrix by concatenation
     1044                    concat_matrix(matrix, matrix_st)
     1045                else:
     1046                    concat_matrix(matrix, [space])
     1047
     1048            def pair_nodes_tree(self, nodes, edges, matrix):
     1049                r"""
     1050                TESTS::
     1051
     1052                    sage: t = OrderedTree([[[],[]],[[],[]]]).\
     1053                    ....:     canonical_labelling(); print latex(t)
     1054                    { \newcommand{\nodea}{\node[draw,circle] (a) {$1$}
     1055                    ;}\newcommand{\nodeb}{\node[draw,circle] (b) {$2$}
     1056                    ;}\newcommand{\nodec}{\node[draw,circle] (c) {$3$}
     1057                    ;}\newcommand{\noded}{\node[draw,circle] (d) {$4$}
     1058                    ;}\newcommand{\nodee}{\node[draw,circle] (e) {$5$}
     1059                    ;}\newcommand{\nodef}{\node[draw,circle] (f) {$6$}
     1060                    ;}\newcommand{\nodeg}{\node[draw,circle] (g) {$7$}
     1061                    ;}\begin{tikzpicture}[auto]
     1062                    \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     1063                             \&         \&         \& \nodea  \&         \&         \&         \\
     1064                             \& \nodeb  \&         \&         \&         \& \nodee  \&         \\
     1065                     \nodec  \&         \& \noded  \&         \& \nodef  \&         \& \nodeg  \\
     1066                    };
     1067                    <BLANKLINE>
     1068                    \path[ultra thick, red] (b) edge (c) edge (d)
     1069                        (e) edge (f) edge (g)
     1070                        (a) edge (b) edge (e);
     1071                    \end{tikzpicture}}
     1072                    sage: t = BinaryTree([[],[[],[]]]); print latex(t)
     1073                    { \newcommand{\nodea}{\node[draw,circle] (a) {$$}
     1074                    ;}\newcommand{\nodeb}{\node[draw,circle] (b) {$$}
     1075                    ;}\newcommand{\nodec}{\node[draw,circle] (c) {$$}
     1076                    ;}\newcommand{\noded}{\node[draw,circle] (d) {$$}
     1077                    ;}\newcommand{\nodee}{\node[draw,circle] (e) {$$}
     1078                    ;}\begin{tikzpicture}[auto]
     1079                    \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     1080                             \& \nodea  \&         \&         \&         \\
     1081                     \nodeb  \&         \&         \& \nodec  \&         \\
     1082                             \&         \& \noded  \&         \& \nodee  \\
     1083                    };
     1084                    <BLANKLINE>
     1085                    \path[ultra thick, red] (c) edge (d) edge (e)
     1086                        (a) edge (b) edge (c);
     1087                    \end{tikzpicture}}
     1088                """
     1089                # build all subtree matrices.
     1090                node, name = create_node(self)
     1091                edge = [name]
     1092                split = int(len(self) / 2)
     1093                # the left part
     1094                for i in range(split):
     1095                    tmp(self[i], edge, nodes, edges, matrix)
     1096                # # prepare the root line
     1097                nb_of_and = matrix[0].count(sep)
     1098                # the middle
     1099                for i in range(len(matrix)):
     1100                    matrix[i] += sepspace
     1101                # the right part
     1102                for i in range(split, len(self)):
     1103                    tmp(self[i], edge, nodes, edges, matrix)
     1104
     1105                # # create the root line
     1106                root_line = (spacesep * (nb_of_and + 1) + node_to_str(node) +
     1107                    sepspace * (matrix[0].count(sep) - nb_of_and - 1))
     1108                matrix.insert(0, root_line)
     1109                # add edges from the root
     1110                edges.append(edge)
     1111
     1112            def odd_nodes_tree(self, nodes, edges, matrix):
     1113                r"""
     1114                TESTS::
     1115
     1116                    sage: t = OrderedTree([[]]).canonical_labelling()
     1117                    sage: print latex(t)
     1118                    { \newcommand{\nodea}{\node[draw,circle] (a) {$1$}
     1119                    ;}\newcommand{\nodeb}{\node[draw,circle] (b) {$2$}
     1120                    ;}\begin{tikzpicture}[auto]
     1121                    \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     1122                     \nodea  \\
     1123                     \nodeb  \\
     1124                    };
     1125                    <BLANKLINE>
     1126                    \path[ultra thick, red] (a) edge (b);
     1127                    \end{tikzpicture}}
     1128                    sage: t = OrderedTree([[[],[]]]).canonical_labelling(); print latex(t)
     1129                    { \newcommand{\nodea}{\node[draw,circle] (a) {$1$}
     1130                    ;}\newcommand{\nodeb}{\node[draw,circle] (b) {$2$}
     1131                    ;}\newcommand{\nodec}{\node[draw,circle] (c) {$3$}
     1132                    ;}\newcommand{\noded}{\node[draw,circle] (d) {$4$}
     1133                    ;}\begin{tikzpicture}[auto]
     1134                    \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     1135                             \& \nodea  \&         \\
     1136                             \& \nodeb  \&         \\
     1137                     \nodec  \&         \& \noded  \\
     1138                    };
     1139                    <BLANKLINE>
     1140                    \path[ultra thick, red] (b) edge (c) edge (d)
     1141                        (a) edge (b);
     1142                    \end{tikzpicture}}
     1143                    sage: t = OrderedTree([[[],[],[]]]).canonical_labelling(); print latex(t)
     1144                    { \newcommand{\nodea}{\node[draw,circle] (a) {$1$}
     1145                    ;}\newcommand{\nodeb}{\node[draw,circle] (b) {$2$}
     1146                    ;}\newcommand{\nodec}{\node[draw,circle] (c) {$3$}
     1147                    ;}\newcommand{\noded}{\node[draw,circle] (d) {$4$}
     1148                    ;}\newcommand{\nodee}{\node[draw,circle] (e) {$5$}
     1149                    ;}\begin{tikzpicture}[auto]
     1150                    \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     1151                             \& \nodea  \&         \\
     1152                             \& \nodeb  \&         \\
     1153                     \nodec  \& \noded  \& \nodee  \\
     1154                    };
     1155                    <BLANKLINE>
     1156                    \path[ultra thick, red] (b) edge (c) edge (d) edge (e)
     1157                        (a) edge (b);
     1158                    \end{tikzpicture}}
     1159                    sage: t = OrderedTree([[[],[],[]],[],[]]).canonical_labelling(); print latex(t)
     1160                    { \newcommand{\nodea}{\node[draw,circle] (a) {$1$}
     1161                    ;}\newcommand{\nodeb}{\node[draw,circle] (b) {$2$}
     1162                    ;}\newcommand{\nodec}{\node[draw,circle] (c) {$3$}
     1163                    ;}\newcommand{\noded}{\node[draw,circle] (d) {$4$}
     1164                    ;}\newcommand{\nodee}{\node[draw,circle] (e) {$5$}
     1165                    ;}\newcommand{\nodef}{\node[draw,circle] (f) {$6$}
     1166                    ;}\newcommand{\nodeg}{\node[draw,circle] (g) {$7$}
     1167                    ;}\begin{tikzpicture}[auto]
     1168                    \matrix[column sep=.3cm, row sep=.3cm,ampersand replacement=\&]{
     1169                             \&         \&         \& \nodea  \&         \\
     1170                             \& \nodeb  \&         \& \nodef  \& \nodeg  \\
     1171                     \nodec  \& \noded  \& \nodee  \&         \&         \\
     1172                    };
     1173                    <BLANKLINE>
     1174                    \path[ultra thick, red] (b) edge (c) edge (d) edge (e)
     1175                        (a) edge (b) edge (f) edge (g);
     1176                    \end{tikzpicture}}
     1177                """
     1178                # build all subtree matrices.
     1179                node, name = create_node(self)
     1180                edge = [name]
     1181                split = int(len(self) / 2)
     1182                # the left part
     1183                for i in range(split):
     1184                    tmp(self[i], edge, nodes, edges, matrix)
     1185                # # prepare the root line
     1186                if len(matrix) != 0:
     1187                    nb_of_and = matrix[0].count(sep)
     1188                    sizetmp = len(matrix[0])
     1189                else:
     1190                    nb_of_and = 0
     1191                    sizetmp = 0
     1192                # the middle
     1193                tmp(self[split], edge, nodes, edges, matrix)
     1194                nb_of_and += matrix[0][sizetmp:].split("node")[0].count(sep)
     1195
     1196                # the right part
     1197                for i in range(split + 1, len(self)):
     1198                    tmp(self[i], edge, nodes, edges, matrix)
     1199
     1200                # # create the root line
     1201                root_line = (spacesep * (nb_of_and) + node_to_str(node) +
     1202                    sepspace * (matrix[0].count(sep) - nb_of_and))
     1203                matrix.insert(0, root_line)
     1204                # add edges from the root
     1205                edges.append(edge)
     1206            if self.is_empty():
     1207                empty_tree()
     1208            elif len(self) == 0 or all(subtree.is_empty()
     1209                    for subtree in self):
     1210                one_node_tree(self)
     1211            elif len(self) % 2 == 0:
     1212                pair_nodes_tree(self, nodes, edges, matrix)
    4681213            else:
    469                 xc = x[0]
    470                 x[0] +=1
    471             drawing[0] = drawing[0] + "\\put(%s,%s){\\circle*{%s}}\n"%(
    472                 xc, maxy-y, self.latex_node_diameter)
    473             try:
    474                 lbl = t.label()
    475             except AttributeError:
    476                 pass
    477             else:
    478                 max_label_width[0] = 1 # TODO find a better heuristic
    479                 drawing[0] = drawing[0] + "\\put(%s,%s){$\scriptstyle %s$}"%(
    480                     xc+0.3, maxy-y-0.3, latex(lbl))
    481             posChild += [rec(t[j], y+1) for j in range(i, n)]
    482             for i in range(n):
    483                 if posChild[i] != -1:
    484                     drawing[0] = (drawing[0] +
    485                         "\\put(%s,%s){\\line(%s,-1){%s}}\n"%(
    486                             xc, maxy-y, posChild[i]-xc,
    487                             max(abs(posChild[i]-xc), 1)))
    488             return xc
     1214                odd_nodes_tree(self, nodes, edges, matrix)
     1215            return nodes, matrix, edges
    4891216
    490         res = rec(self, 0)
    491         drawing[0] = drawing[0] + "\\put(%s,%s){\\circle*{%s}}\n"%(
    492             res, maxy, self.latex_root_diameter)
    493         return "\\vcenter{\hbox{{\setlength\unitlength{%s}\n\\begin{picture}(%s,%s)\n%s\\end{picture}}}}"%(
    494             self.latex_unit_length,
    495             x[0] + max_label_width[0],
    496             maxy + 1,
    497             drawing[0])
     1217        nodes, matrix, edges = resolve(self)
     1218
     1219        def make_cmd(nodes):
     1220            cmds = []
     1221            for name, label in nodes:
     1222                cmds.append(new_cmd1 + name + new_cmd2 +
     1223                    name + new_cmd3 +
     1224                    label + new_cmd4)
     1225            return cmds
     1226
     1227        def make_edges(edges):
     1228            all_paths = []
     1229            for edge in edges:
     1230                path = "(" + edge[0] + ")"
     1231                for i in range(1, len(edge)):
     1232                    path += " edge (%s)" % edge[i]
     1233                all_paths.append(path)
     1234            return all_paths
     1235        return ("{ " +
     1236            "".join(make_cmd(nodes)) +
     1237            begin_env +
     1238                (matrix_begin +
     1239                    "\\\\ \n".join(matrix) +
     1240                matrix_end +
     1241                ("\n" +
     1242                path_begin +
     1243                    "\n\t".join(make_edges(edges)) +
     1244                path_end if len(edges) > 0 else "")
     1245                if len(matrix) > 0 else "") +
     1246            end_env +
     1247            "}")
     1248
    4981249
    4991250class AbstractClonableTree(AbstractTree):
    5001251    """
  • sage/combinat/binary_tree.py

    diff --git a/sage/combinat/binary_tree.py b/sage/combinat/binary_tree.py
    a b  
     1# -*- coding: utf-8 -*-
    12"""
    2 Binary trees
    3 
    4 This module deals with binary trees as mathematical (in particular immmutable)
     3Binary Trees
     4
     5This module deals with binary trees as mathematical (in particular immutable)
    56objects.
    67
    7 .. NOTE :: If you need the data-structure for example to represent sets or hash
    8            tables with AVL trees, you should have a look at
    9            :mod:`sage.misc.sagex_ds`.
    10 
    11 **AUTHORS:**
     8.. NOTE::
     9
     10    If you need the data-structure for example to represent sets or hash
     11    tables with AVL trees, you should have a look at :mod:`sage.misc.sagex_ds`.
     12
     13AUTHORS:
    1214
    1315- Florent Hivert (2010-2011): initial implementation.
     16
     17REFERENCES:
     18
     19.. [LodayRonco] Jean-Louis Loday and María O. Ronco.
     20   *Hopf algebra of the planar binary trees*,
     21   Advances in Mathematics, volume 139, issue 2,
     22   10 November 1998, pp. 293-309.
     23   http://www.sciencedirect.com/science/article/pii/S0001870898917595
     24
     25.. [HNT05] Florent Hivert, Jean-Christophe Novelli, and Jean-Yves Thibon.
     26   *The algebra of binary search trees*,
     27   :arxiv:`math/0401089v2`.
     28
     29.. [CP12] Gregory Chatel, Vivane Pons.
     30   *Counting smaller trees in the Tamari order*,
     31   :arxiv:`1212.0751v1`.
    1432"""
    1533#*****************************************************************************
    1634#       Copyright (C) 2010 Florent Hivert <Florent.Hivert@univ-rouen.fr>,
    from sage.combinat.combinatorial_map imp 
    3149
    3250class BinaryTree(AbstractClonableTree, ClonableArray):
    3351    """
    34     The class of binary trees
    35 
    36     Binary trees here mean ordered (a.k.a. plane) binary trees,
    37     meaning that the children of each node are ordered.
     52    Binary trees.
     53
     54    Binary trees here mean ordered (a.k.a. plane) finite binary
     55    trees, where "ordered" means that the children of each node are
     56    ordered.
     57
     58    Binary trees contain nodes and leaves, where each node has two
     59    children while each leaf has no children. The number of leaves
     60    always equals the number of nodes plus `1`.
    3861
    3962    INPUT:
    4063
    4164    - ``children`` -- ``None`` (default) or a list, tuple or iterable of
    42       length 2 of binary trees or convertible objects. This corresponds to
    43       the standard recursive definition of a binary tree as either a leaf
    44       or a pair of binary trees. Syntactic sugar allows leaving out all
    45       but the outermost calls of the ``BinaryTree()`` constructor, so that,
    46       e. g., ``BinaryTree([BinaryTree(None),BinaryTree(None)])`` can be
    47       simplified to ``BinaryTree([None,None])``. It is also allowed to
     65      length `2` of binary trees or convertible objects. This corresponds
     66      to the standard recursive definition of a binary tree as either a
     67      leaf or a pair of binary trees. Syntactic sugar allows leaving out
     68      all but the outermost calls of the ``BinaryTree()`` constructor, so
     69      that, e. g., ``BinaryTree([BinaryTree(None),BinaryTree(None)])`` can
     70      be simplified to ``BinaryTree([None,None])``. It is also allowed to
    4871      abbreviate ``[None, None]`` by ``[]``.
    4972
    5073    - ``check`` -- (default to ``True``) whether check for binary should be
    class BinaryTree(AbstractClonableTree, C 
    87110    def __classcall_private__(cls, *args, **opts):
    88111        """
    89112        Ensure that binary trees created by the enumerated sets and directly
    90         are the same and that they are instances of :class:`BinaryTree`
     113        are the same and that they are instances of :class:`BinaryTree`.
    91114
    92115        TESTS::
    93116
    class BinaryTree(AbstractClonableTree, C 
    117140    @lazy_class_attribute
    118141    def _auto_parent(cls):
    119142        """
    120         The automatic parent of the element of this class
     143        The automatic parent of the elements of this class.
    121144
    122145        When calling the constructor of an element of this class, one needs a
    123146        parent. This class attribute specifies which parent is used.
    class BinaryTree(AbstractClonableTree, C 
    128151            Binary trees
    129152            sage: BinaryTree([None, None]).parent()
    130153            Binary trees
    131          """
     154        """
    132155        return BinaryTrees_all()
    133156
    134157    def __init__(self, parent, children = None, check = True):
    class BinaryTree(AbstractClonableTree, C 
    164187
    165188    def check(self):
    166189        """
    167         Checks that ``self`` is a binary tree
     190        Check that ``self`` is a binary tree.
    168191
    169192        EXAMPLES::
    170193
    class BinaryTree(AbstractClonableTree, C 
    400423
    401424    def is_empty(self):
    402425        """
    403         Return whether ``self`` is  empty.
     426        Return whether ``self`` is empty.
     427
     428        The notion of emptiness employed here is the one which defines
     429        a binary tree to be empty if its root is a leaf. There is
     430        precisely one empty binary tree.
    404431
    405432        EXAMPLES::
    406433
    class BinaryTree(AbstractClonableTree, C 
    413440        """
    414441        return not self
    415442
    416     def graph(self):
     443    def graph(self, with_leaves=True):
    417444        """
    418         Convert ``self`` to a digraph
    419 
    420         EXAMPLE::
     445        Convert ``self`` to a digraph. By default, this graph contains
     446        both nodes and leaves, hence is never empty. To obtain a graph
     447        which contains only the nodes, the ``with_leaves`` optional
     448        keyword variable has to be set to ``False``.
     449
     450        INPUT:
     451
     452        - ``with_leaves`` -- (default: ``True``) a Boolean, determining
     453          whether the resulting graph will be formed from the leaves
     454          and the nodes of ``self`` (if ``True``), or only from the
     455          nodes of ``self`` (if ``False``)
     456
     457        EXAMPLES::
    421458
    422459            sage: t1 = BinaryTree([[], None])
    423460            sage: t1.graph()
    424461            Digraph on 5 vertices
     462            sage: t1.graph(with_leaves=False)
     463            Digraph on 2 vertices
    425464
    426465            sage: t1 = BinaryTree([[], [[], None]])
    427466            sage: t1.graph()
    428467            Digraph on 9 vertices
    429468            sage: t1.graph().edges()
    430469            [(0, 1, None), (0, 4, None), (1, 2, None), (1, 3, None), (4, 5, None), (4, 8, None), (5, 6, None), (5, 7, None)]
     470            sage: t1.graph(with_leaves=False)
     471            Digraph on 4 vertices
     472            sage: t1.graph(with_leaves=False).edges()
     473            [(0, 1, None), (0, 2, None), (2, 3, None)]
     474
     475            sage: t1 = BinaryTree()
     476            sage: t1.graph()
     477            Digraph on 1 vertex
     478            sage: t1.graph(with_leaves=False)
     479            Digraph on 0 vertices
     480
     481            sage: BinaryTree([]).graph()
     482            Digraph on 3 vertices
     483            sage: BinaryTree([]).graph(with_leaves=False)
     484            Digraph on 1 vertex
     485
     486            sage: t1 = BinaryTree([[], [[], []]])
     487            sage: t1.graph(with_leaves=False)
     488            Digraph on 5 vertices
     489            sage: t1.graph(with_leaves=False).edges()
     490            [(0, 1, None), (0, 2, None), (2, 3, None), (2, 4, None)]
    431491        """
    432492        from sage.graphs.graph import DiGraph
    433         res = DiGraph()
    434         def rec(tr, idx):
    435             if not tr:
    436                 return
    437             else:
    438                 nbl = 2*tr[0].node_number() + 1
    439                 res.add_edges([[idx,idx+1], [idx,idx+1+nbl]])
    440                 rec(tr[0], idx + 1)
    441                 rec(tr[1], idx + nbl + 1)
    442         rec(self, 0)
    443         return res
     493
     494        if with_leaves:   # We want leaves and nodes.
     495
     496            # Special treatment for the case when self has only 1 vertex.
     497            # In this case, rec(self, 0) would give a false result.
     498            if not self:
     499                return DiGraph([[0], lambda i,j: False])
     500   
     501            res = DiGraph()
     502            # The edge set of res will be built up step by step using the
     503            # following function:
     504            def rec(tr, idx):
     505                if not tr:  # tr is a leaf.
     506                    return
     507                else:  # tr is a node.
     508                    nbl = 2*tr[0].node_number() + 1
     509                    res.add_edges([[idx,idx+1], [idx,idx+1+nbl]])
     510                    rec(tr[0], idx + 1)
     511                    rec(tr[1], idx + nbl + 1)
     512            rec(self, 0)
     513            return res
     514
     515        else:   # We want only the nodes.
     516
     517            # Special treatment for the case when self has only 1 node.
     518            # In this case, the general DiGraph construction would
     519            # falsely yield an empty graph (since it adds nodes only
     520            # implicitly by adding edges).
     521            if self.node_number() == 1:
     522                return DiGraph([[0], lambda i,j: False])
     523
     524            res = DiGraph()
     525            # The edge set of res will be built up step by step using the
     526            # following function:
     527            def rec(tr, idx):
     528                if not tr:  # tr is a leaf.
     529                    return
     530                else:  # tr is a node.
     531                    nbl = tr[0].node_number()
     532                    if nbl > 0:
     533                        res.add_edge([idx, idx + 1])
     534                        rec(tr[0], idx + 1)
     535                    if tr[1].node_number() > 0:
     536                        res.add_edge([idx, idx + nbl + 1])
     537                        rec(tr[1], idx + nbl + 1)
     538            rec(self, 0)
     539            return res
    444540
    445541    def canonical_labelling(self,shift=1):
    446542        """
    447543        Return a labelled version of ``self``.
    448544
     545        The canonical labelling of a binary tree is a certain labelling of the
     546        nodes (not the leaves) of the tree.
    449547        The actual canonical labelling is currently unspecified. However, it
    450548        is guaranteed to have labels in `1...n` where `n` is the number of
    451549        nodes of the tree. Moreover, two (unlabelled) trees compare as equal if
    class BinaryTree(AbstractClonableTree, C 
    469567        else:
    470568            return LTR(None)
    471569
    472     def show(self):
     570    def show(self, with_leaves=False):
    473571        """
     572        Show the binary tree ``show``, with or without leaves depending
     573        on the Boolean keyword variable ``with_leaves``.
     574
     575        .. WARNING::
     576
     577            Left and right children might get interchanged in
     578            the actual picture.
     579
    474580        TESTS::
    475581
    476582            sage: t1 = BinaryTree([[], [[], None]])
    477583            sage: t1.show()
    478584        """
    479         self.graph().show(layout='tree', tree_root=0, tree_orientation="down")
     585        try:
     586            self.graph(with_leaves=with_leaves).show(layout='tree', tree_root=0, tree_orientation="down")
     587        except RuntimeError:
     588            # This is for the border case BinaryTree().show().
     589            self.graph(with_leaves=with_leaves).show()
    480590
    481591    def make_node(self, child_list = [None, None]):
    482592        """
    483         Modify ``self`` so that it becomes a node with children ``childlist``
     593        Modify ``self`` so that it becomes a node with children ``child_list``.
    484594
    485595        INPUT:
    486596
    class BinaryTree(AbstractClonableTree, C 
    499609            ...
    500610            ValueError: object is immutable; please change a copy instead.
    501611            sage: with t.clone() as t1:
    502             ...    t1.make_node([None, None])
     612            ....:     t1.make_node([None, None])
    503613            sage: t, t1
    504614            (., [., .])
    505615            sage: with t.clone() as t:
    506             ...    t.make_node([BinaryTree(), BinaryTree(), BinaryTree([])])
     616            ....:     t.make_node([BinaryTree(), BinaryTree(), BinaryTree([])])
    507617            Traceback (most recent call last):
    508618            ...
    509619            ValueError: the list must have length 2
    510620            sage: with t1.clone() as t2:
    511             ...    t2.make_node([t1, t1])
     621            ....:     t2.make_node([t1, t1])
    512622            sage: with t2.clone() as t3:
    513             ...    t3.make_node([t1, t2])
     623            ....:     t3.make_node([t1, t2])
    514624            sage: t1, t2, t3
    515625            ([., .], [[., .], [., .]], [[., .], [[., .], [., .]]])
    516626        """
    class BinaryTree(AbstractClonableTree, C 
    522632
    523633    def make_leaf(self):
    524634        """
    525         Modify ``self`` so that it became a leaf
     635        Modify ``self`` so that it becomes a leaf (i. e., an empty tree).
    526636
    527637        .. NOTE:: ``self`` must be in a mutable state.
    528638
    class BinaryTree(AbstractClonableTree, C 
    537647            ...
    538648            ValueError: object is immutable; please change a copy instead.
    539649            sage: with t.clone() as t1:
    540             ...    t1.make_leaf()
     650            ....:     t1.make_leaf()
    541651            sage: t, t1
    542652            ([., .], .)
    543653        """
    class BinaryTree(AbstractClonableTree, C 
    574684    def to_dyck_word_tamari(self):
    575685        r"""
    576686        Return the Dyck word associated with ``self`` in consistency with
    577         the Tamari order on dyck words and binary trees.
     687        the Tamari order on Dyck words and binary trees.
    578688
    579689        The bijection is defined recursively as follows:
    580690
    class BinaryTree(AbstractClonableTree, C 
    594704            sage: BinaryTree([[[], [[], None]], [[], []]]).to_dyck_word_tamari()
    595705            [1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0]
    596706        """
    597         from sage.combinat.dyck_word import DyckWord
    598707        return self.to_dyck_word("L1R0")
    599708
    600709    @combinatorial_map(name="to Dyck paths: up step, left tree, down step, right tree")
    601710    def to_dyck_word(self, usemap="1L0R"):
    602711        r"""
     712        Return the Dyck word associated with ``self`` using the given map.
     713
    603714        INPUT:
    604715
    605716        - ``usemap`` -- a string, either ``1L0R``, ``1R0L``, ``L1R0``, ``R1L0``
    606717
    607         Return the Dyck word associated with ``self`` using the given map.
    608 
    609718        The bijection is defined recursively as follows:
    610719
    611720        - a leaf is associated to the empty Dyck Word
    612721
    613722        - a tree with children `l,r` is associated with the Dyck word
    614723          described by ``usemap`` where `L` and `R` are respectively the
    615           Dyck words associated with the `l` and `r`.
     724          Dyck words associated with the trees `l` and `r`.
    616725
    617726        EXAMPLES::
    618727
    class BinaryTree(AbstractClonableTree, C 
    717826    @combinatorial_map(name="To ordered tree, right child = right brother")
    718827    def to_ordered_tree_right_branch(self):
    719828        r"""
    720         Return an ordered tree of size n+1 by the following recursive rule:
     829        Return an ordered tree of size `n+1` by the following recursive rule:
    721830
    722831        - if `x` is the right child of `y`, `x` becomes the right brother
    723832          of `y`
    class BinaryTree(AbstractClonableTree, C 
    773882        Return a 312-avoiding permutation corresponding to the binary tree.
    774883
    775884        The linear extensions of a binary tree form an interval of the weak
    776         order called the sylester class of the tree. This permutation is
     885        order called the sylvester class of the tree. This permutation is
    777886        the minimal element of this sylvester class.
    778887
    779888        EXAMPLES::
    class BinaryTree(AbstractClonableTree, C 
    798907        return Permutation(self._postfix_word())
    799908
    800909    @combinatorial_map(name="To complete tree")
    801     def as_ordered_tree(self,with_leaves=True):
     910    def as_ordered_tree(self, with_leaves=True):
    802911        r"""
    803912        Return the same tree seen as an ordered tree. By default, leaves
    804         are transformed into actual nodes.
     913        are transformed into actual nodes, but this can be avoided by
     914        setting the optional variable ``with_leaves`` to ``False``.
    805915
    806916        EXAMPLES::
    807917
    class BinaryTree(AbstractClonableTree, C 
    821931        if with_leaves:
    822932            children = [child.as_ordered_tree(with_leaves) for child in self]
    823933        else:
     934            if not self:
     935                raise ValueError("The empty binary tree cannot be made into an ordered tree with with_leaves = False")
    824936            children = [child.as_ordered_tree(with_leaves) for child in self if not child.is_empty()]
    825937        if self in LabelledBinaryTrees():
    826938            from sage.combinat.ordered_tree import LabelledOrderedTree
    class BinaryTree(AbstractClonableTree, C 
    830942            return OrderedTree(children)
    831943
    832944    @combinatorial_map(name="To graph")
    833     def to_undirected_graph(self, with_leaves = False):
     945    def to_undirected_graph(self, with_leaves=False):
    834946        r"""
    835947        Return the undirected graph obtained from the tree nodes and edges.
    836         Leafs are ignored by default but can set ``with_leaves`` to ``True``
    837         to obtain the graph of the complete tree.
     948        Leaves are ignored by default, but one can set ``with_leaves`` to
     949        ``True`` to obtain the graph of the complete tree.
     950
     951        INPUT:
     952
     953        - ``with_leaves`` -- (default: ``False``) a Boolean, determining
     954          whether the resulting graph will be formed from the leaves
     955          and the nodes of ``self`` (if ``True``), or only from the
     956          nodes of ``self`` (if ``False``)
    838957
    839958        EXAMPLES::
    840959
    class BinaryTree(AbstractClonableTree, C 
    844963            sage: bt.to_undirected_graph(with_leaves=True)
    845964            Graph on 3 vertices
    846965
     966            sage: bt = BinaryTree()
     967            sage: bt.to_undirected_graph()
     968            Graph on 0 vertices
     969            sage: bt.to_undirected_graph(with_leaves=True)
     970            Graph on 1 vertex
     971
    847972        If the tree is labelled, we use its labelling to label the graph.
    848973        Otherwise, we use the graph canonical labelling which means that
    849974        two different trees can have the same graph.
    class BinaryTree(AbstractClonableTree, C 
    862987            sage: BinaryTree([[],[]]).to_undirected_graph() == BinaryTree([[[],None],None]).to_undirected_graph()
    863988            True
    864989        """
     990        if (not with_leaves) and (not self):
     991            # this case needs extra care :(
     992            from sage.graphs.graph import Graph
     993            return Graph([])
    865994        return self.as_ordered_tree(with_leaves).to_undirected_graph()
    866995
    867996    @combinatorial_map(name="To poset")
    868     def to_poset(self, with_leaves = False, root_to_leaf=False):
     997    def to_poset(self, with_leaves=False, root_to_leaf=False):
    869998        r"""
    870         Return the poset obtained by interpreting the tree as a hasse
     999        Return the poset obtained by interpreting the tree as a Hasse
    8711000        diagram.
    8721001
    8731002        The default orientation is from leaves to root but you can
    8741003        pass ``root_to_leaf=True`` to obtain the inverse orientation.
    8751004
    876         Leafs are ignored by default but can set ``with_leaves`` to ``True``
    877         to obtain the poset of the complete tree.
     1005        Leaves are ignored by default, but one can set ``with_leaves`` to
     1006        ``True`` to obtain the poset of the complete tree.
    8781007
    8791008        INPUT:
    8801009
    881         - ``with_leaves`` -- boolean, true if leaves should be added to the poset
    882         - ``root_to_leaf`` -- boolean, true if the poset orientation should
    883           be from root to leaves. It is false by default.
     1010        - ``with_leaves`` -- (default: ``False``) a Boolean, determining
     1011          whether the resulting poset will be formed from the leaves
     1012          and the nodes of ``self`` (if ``True``), or only from the
     1013          nodes of ``self`` (if ``False``)
     1014        - ``root_to_leaf`` -- (default: ``False``) a Boolean,
     1015          determining whether the poset orientation should be from root
     1016          to leaves (if ``True``) or from leaves to root (if ``False``).
    8841017
    8851018        EXAMPLES::
    8861019
    class BinaryTree(AbstractClonableTree, C 
    9031036            2[1[., .], 3[., 4[., .]]]
    9041037            sage: bt.to_poset().cover_relations()
    9051038            [[4, 3], [3, 2], [1, 2]]
     1039
     1040        Let us check that the empty binary tree is correctly handled::
     1041
     1042            sage: bt = BinaryTree()
     1043            sage: bt.to_poset()
     1044            Finite poset containing 0 elements
     1045            sage: bt.to_poset(with_leaves=True)
     1046            Finite poset containing 1 elements
    9061047        """
     1048        if (not with_leaves) and (not self):
     1049            # this case needs extra care :(
     1050            from sage.combinat.posets.posets import Poset
     1051            return Poset({})
    9071052        return self.as_ordered_tree(with_leaves).to_poset(root_to_leaf)
    9081053
    9091054    @combinatorial_map(name="To 132 avoiding permutation")
    class BinaryTree(AbstractClonableTree, C 
    9121057        Return a 132-avoiding permutation corresponding to the binary tree.
    9131058
    9141059        The linear extensions of a binary tree form an interval of the weak
    915         order called the sylester class of the tree. This permutation is
     1060        order called the sylvester class of the tree. This permutation is
    9161061        the maximal element of this sylvester class.
    9171062
    9181063        EXAMPLES::
    class BinaryTree(AbstractClonableTree, C 
    10031148
    10041149    def canopee(self):
    10051150        """
    1006         Return the canopee of ``self``
    1007 
    1008         The *canopee* of a non empty binary tree `T` with `n` internal nodes is
     1151        Return the canopee of ``self``.
     1152
     1153        The *canopee* of a non-empty binary tree `T` with `n` internal nodes is
    10091154        the list `l` of `0` and `1` of length `n-1` obtained by going along the
    10101155        leaves of `T` from left to right except the two extremal ones, writing
    10111156        `0` if the leaf is a right leaf and `1` if the leaf is a left leaf.
    class BinaryTree(AbstractClonableTree, C 
    10251170
    10261171        The number of pairs `(t_1, t_2)` of binary trees of size `n` such that
    10271172        the canopee of `t_1` is the complementary of the canopee of `t_2` is
    1028         also the number of Baxter permutations (see [DG]_, see
     1173        also the number of Baxter permutations (see [DG94]_, see
    10291174        also :oeis:`A001181`). We check this in small cases::
    10301175
    10311176            sage: [len([(u,v) for u in BinaryTrees(n) for v in BinaryTrees(n)
    1032             ...       if map(lambda x:1-x, u.canopee()) == v.canopee()])
    1033             ...    for n in range(1, 5)]
     1177            ....:       if map(lambda x:1-x, u.canopee()) == v.canopee()])
     1178            ....:    for n in range(1, 5)]
    10341179            [1, 2, 6, 22]
    10351180
    10361181        Here is a less trivial implementation of this::
    class BinaryTree(AbstractClonableTree, C 
    10381183            sage: from sage.sets.finite_set_map_cy import fibers
    10391184            sage: from sage.misc.all import attrcall
    10401185            sage: def baxter(n):
    1041             ...      f = fibers(lambda t: tuple(t.canopee()),
    1042             ...                   BinaryTrees(n))
    1043             ...      return sum(len(f[i])*len(f[tuple(1-x for x in i)])
    1044             ...                 for i in f)
     1186            ....:     f = fibers(lambda t: tuple(t.canopee()),
     1187            ....:                   BinaryTrees(n))
     1188            ....:     return sum(len(f[i])*len(f[tuple(1-x for x in i)])
     1189            ....:                for i in f)
    10451190            sage: [baxter(n) for n in range(1, 7)]
    10461191            [1, 2, 6, 22, 92, 422]
    10471192
    class BinaryTree(AbstractClonableTree, C 
    10541199
    10551200        REFERENCES:
    10561201
    1057             .. [DG] S. Dulucq and O, Guibert. Mots de piles, tableaux
    1058                standards et permutations de Baxter, proceedings of
    1059                Formal Power Series and Algebraic Combinatorics, 1994.
     1202        .. [DG94] S. Dulucq and O. Guibert. Mots de piles, tableaux
     1203           standards et permutations de Baxter, proceedings of
     1204           Formal Power Series and Algebraic Combinatorics, 1994.
    10601205        """
    10611206        if not self:
    10621207            raise ValueError("canopee is only defined for non empty binary trees")
    class BinaryTree(AbstractClonableTree, C 
    10691214                    res.append(1-i)
    10701215        add_leaf_rec(self)
    10711216        return res[1:-1]
     1217
     1218    def in_order_traversal_iter(self):
     1219        """
     1220        The depth-first infix-order traversal iterator for the binary
     1221        tree ``self``.
     1222
     1223        This method iters each vertex (node and leaf alike) following the
     1224        depth-first infix order traversal algorithm.
     1225
     1226        The *depth-first infix order traversal algorithm* iterates
     1227        through a binary tree as follows::
     1228
     1229            iterate through the left subtree (by the depth-first infix
     1230                order traversal algorithm);
     1231            yield the root;
     1232            iterate through the right subtree (by the depth-first infix
     1233                order traversal algorithm).
     1234
     1235        For example on the following binary tree `T`, where we denote
     1236        leaves by `a, b, c, \ldots` and nodes by `1, 2, 3, \ldots`::
     1237
     1238            |     ____3____          |
     1239            |    /         \         |
     1240            |   1          __7__     |
     1241            |  / \        /     \    |
     1242            | a   2      _5_     8   |
     1243            |    / \    /   \   / \  |
     1244            |   b   c  4     6 h   i |
     1245            |         / \   / \      |
     1246            |        d   e f   g     |
     1247
     1248        the depth-first infix-order traversal algorithm iterates through
     1249        the vertices of `T` in the following order:
     1250        `a,1,b,2,c,3,d,4,e,5,f,6,g,7,h,8,i`.
     1251
     1252        See :meth:`in_order_traversal` for a version of this algorithm
     1253        which not only iterates through, but actually does something at
     1254        the vertices of tree.
     1255
     1256        TESTS::
     1257
     1258            sage: b = BinaryTree([[],[[],[]]]); ascii_art([b])
     1259            [   _o_     ]
     1260            [  /   \    ]
     1261            [ o     o   ]
     1262            [      / \  ]
     1263            [     o   o ]
     1264            sage: ascii_art(list(b.in_order_traversal_iter()))
     1265            [                                       ]
     1266            [ , o, ,   _o_        o      o      o   ]
     1267            [         /   \             / \         ]
     1268            [        o     o           o   o        ]
     1269            [             / \                       ]
     1270            [            o   o, ,  , ,      , ,  ,  ]
     1271            sage: ascii_art(filter(lambda node: node.label() is not None,
     1272            ....:     b.canonical_labelling().in_order_traversal_iter()))
     1273            [                           ]
     1274            [ 1,   _2_      3    4    5 ]
     1275            [     /   \         / \     ]
     1276            [    1     4       3   5    ]
     1277            [         / \               ]
     1278            [        3   5,  ,      ,   ]
     1279        """
     1280        if self.is_empty():
     1281            yield self
     1282            return
     1283        # TODO:: PYTHON 3
     1284        # yield from self[0].in_order_traversal_iter()
     1285        for left_subtree in self[0].in_order_traversal_iter():
     1286            yield left_subtree
     1287        yield self
     1288        # TODO:: PYTHON 3
     1289        # yield from self[1].in_order_traversal_iter()
     1290        for right_subtree in self[1].in_order_traversal_iter():
     1291            yield right_subtree
     1292
     1293    def in_order_traversal(self, node_action=None, leaf_action=None):
     1294        r"""
     1295        Explore the binary tree ``self`` using the depth-first infix-order
     1296        traversal algorithm, executing the ``node_action`` function
     1297        whenever traversing a node and executing the ``leaf_action``
     1298        function whenever traversing a leaf.
     1299
     1300        In more detail, what this method does to a tree `T` is the
     1301        following::
     1302
     1303            if the root of `T` is a node:
     1304                apply in_order_traversal to the left subtree of `T`
     1305                    (with the same node_action and leaf_action);
     1306                apply node_action to the root of `T`;
     1307                apply in_order_traversal to the right subtree of `T`
     1308                    (with the same node_action and leaf_action);
     1309            else:
     1310                apply leaf_action to the root of `T`.
     1311
     1312        For example on the following binary tree `T`, where we denote
     1313        leaves by `a, b, c, \ldots` and nodes by `1, 2, 3, \ldots`::
     1314
     1315            |     ____3____          |
     1316            |    /         \         |
     1317            |   1          __7__     |
     1318            |  / \        /     \    |
     1319            | a   2      _5_     8   |
     1320            |    / \    /   \   / \  |
     1321            |   b   c  4     6 h   i |
     1322            |         / \   / \      |
     1323            |        d   e f   g     |
     1324
     1325        this method first applies ``leaf_action`` to `a`, then applies
     1326        ``node_action`` to `1`, then ``leaf_action`` to `b`, then
     1327        ``node_action`` to `2`, etc., with the vertices being traversed
     1328        in the order `a,1,b,2,c,3,d,4,e,5,f,6,g,7,h,8,i`.
     1329
     1330        See :meth:`in_order_traversal_iter` for a version of this
     1331        algorithm which only iterates through the vertices rather than
     1332        applying any function to them.
     1333
     1334        INPUT:
     1335
     1336        - ``node_action`` -- (optional) a function which takes a node in input
     1337          and does something during the exploration
     1338        - ``leaf_action`` -- (optional) a function which takes a leaf in input
     1339          and does something during the exploration
     1340
     1341        TESTS::
     1342
     1343            sage: nb_leaf = 0
     1344            sage: def l_action(_):
     1345            ....:    global nb_leaf
     1346            ....:    nb_leaf += 1
     1347            sage: nb_node = 0
     1348            sage: def n_action(_):
     1349            ....:    global nb_node
     1350            ....:    nb_node += 1
     1351            sage: BinaryTree().in_order_traversal(n_action, l_action)
     1352            sage: nb_leaf, nb_node
     1353            (1, 0)
     1354            sage: nb_leaf, nb_node = 0, 0
     1355            sage: b = BinaryTree([[],[[],[]]]); b
     1356            [[., .], [[., .], [., .]]]
     1357            sage: b.in_order_traversal(n_action, l_action)
     1358            sage: nb_leaf, nb_node
     1359            (6, 5)
     1360            sage: nb_leaf, nb_node = 0, 0
     1361            sage: b = b.canonical_labelling()
     1362            sage: b.in_order_traversal(n_action, l_action)
     1363            sage: nb_leaf, nb_node
     1364            (6, 5)
     1365            sage: l = []
     1366            sage: b.in_order_traversal(lambda node: l.append( node.label() ))
     1367            sage: l
     1368            [1, 2, 3, 4, 5]
     1369            sage: leaf = 'a'
     1370            sage: l = []
     1371            sage: def l_action(_):
     1372            ....:    global leaf, l
     1373            ....:    l.append(leaf)
     1374            ....:    leaf = chr( ord(leaf)+1 )
     1375            sage: n_action = lambda node: l.append( node.label() )
     1376            sage: b = BinaryTree([[None,[]],[[[],[]],[]]]).\
     1377            ....:     canonical_labelling()
     1378            sage: b.in_order_traversal(n_action, l_action)
     1379            sage: l
     1380            ['a', 1, 'b', 2, 'c', 3, 'd', 4, 'e', 5, 'f', 6, 'g', 7, 'h', 8,
     1381             'i']
     1382        """
     1383        if leaf_action is None:
     1384            leaf_action = lambda x: None
     1385        if node_action is None:
     1386            node_action = lambda x: None
     1387
     1388        for node in self.in_order_traversal_iter():
     1389            if node.is_empty():
     1390                leaf_action(node)
     1391            else:
     1392                node_action(node)
     1393
     1394    def tamari_greater(self):
     1395        r"""
     1396        The list of all trees greater or equal to ``self`` in the Tamari
     1397        order.
     1398        This is the transitive ideal of its successors.
     1399
     1400        The Tamari order on binary trees of size `n` is the partial order
     1401        on the set of all binary trees of size `n` generated by the
     1402        following requirement:  If a binary tree `T'` is obtained by
     1403        right rotation (see :meth:`right_rotate`) from a binary tree `T`,
     1404        then `T < T'`.
     1405        This not only is a well-defined partial order, but actually is
     1406        a lattice structure on the set of binary trees of size `n`, and
     1407        is a quotient of the weak order on the `n`-th symmetric group.
     1408        See [CP12]_.
     1409
     1410        For example, the tree::
     1411
     1412            |     __o__   |
     1413            |    /     \  |
     1414            |   o       o |
     1415            |  / \     /  |
     1416            | o   o   o   |
     1417
     1418        has these trees greater or equal to it::
     1419
     1420            |o          , o        , o        , o        ,  o       ,   o      ,|
     1421            | \            \          \          \           \           \      |
     1422            |  o            o          o           o         _o_        __o__   |
     1423            |   \            \          \           \       /   \      /     \  |
     1424            |    o            o          o          _o_    o     o    o       o |
     1425            |     \            \        / \        /   \    \     \    \     /  |
     1426            |      o            o      o   o      o     o    o     o    o   o   |
     1427            |       \            \          \          /                        |
     1428            |        o            o          o        o                         |
     1429            |         \          /                                              |
     1430            |          o        o                                               |
     1431            <BLANKLINE>
     1432            |   o        ,   o      ,   _o_      ,   _o__     ,   __o__    ,   ___o___  ,|
     1433            |  / \          / \        /   \        /    \       /     \      /       \  |
     1434            | o   o        o   o      o     o      o     _o_    o       o    o         o |
     1435            |      \            \          / \          /   \    \       \    \       /  |
     1436            |       o            o        o   o        o     o    o       o    o     o   |
     1437            |        \            \            \            /      \            \        |
     1438            |         o            o            o          o        o            o       |
     1439            |          \          /                                                      |
     1440            |           o        o                                                       |
     1441            <BLANKLINE>
     1442            |     _o_    ,     __o__  |
     1443            |    /   \        /     \ |
     1444            |   o     o      o       o|
     1445            |  / \     \    / \     / |
     1446            | o   o     o  o   o   o  |
     1447
     1448        TESTS::
     1449
     1450            sage: B = BinaryTree
     1451            sage: b = B([None, B([None, B([None, B([])])])]);b
     1452            [., [., [., [., .]]]]
     1453            sage: b.tamari_greater()
     1454            [[., [., [., [., .]]]]]
     1455            sage: b = B([B([B([B([]), None]), None]), None]);b
     1456            [[[[., .], .], .], .]
     1457            sage: b.tamari_greater()
     1458            [[., [., [., [., .]]]], [., [., [[., .], .]]], [., [[., .], [., .]]], [., [[., [., .]], .]], [., [[[., .], .], .]], [[., .], [., [., .]]], [[., .], [[., .], .]], [[., [., .]], [., .]], [[., [., [., .]]], .], [[., [[., .], .]], .], [[[., .], .], [., .]], [[[., .], [., .]], .], [[[., [., .]], .], .], [[[[., .], .], .], .]]
     1459        """
     1460        from sage.combinat.tools import transitive_ideal
     1461        return transitive_ideal(lambda x: x.tamari_succ(), self)
     1462
     1463    def tamari_pred(self):
     1464        r"""
     1465        Compute the list of predecessors of ``self`` in the Tamari poset.
     1466        This list is computed by all left rotate possible on
     1467        its nodes.
     1468
     1469        For this tree::
     1470
     1471            |     __o__   |
     1472            |    /     \  |
     1473            |   o       o |
     1474            |  / \     /  |
     1475            | o   o   o   |
     1476
     1477        the list is::
     1478
     1479            |        o ,       _o_   |
     1480            |       /         /   \  |
     1481            |     _o_        o     o |
     1482            |    /   \      /     /  |
     1483            |   o     o    o     o   |
     1484            |  / \        /          |
     1485            | o   o      o           |
     1486
     1487        TESTS::
     1488
     1489            sage: B = BinaryTree
     1490            sage: b = B([B([B([B([]), None]), None]), None]);b
     1491            [[[[., .], .], .], .]
     1492            sage: b.tamari_pred()
     1493            []
     1494            sage: b = B([None, B([None, B([None, B([])])])]);b
     1495            [., [., [., [., .]]]]
     1496            sage: b.tamari_pred()
     1497            [[[., .], [., [., .]]], [., [[., .], [., .]]], [., [., [[., .], .]]]]
     1498        """
     1499        res = []
     1500        if self.is_empty():
     1501            return []
     1502        if not self[1].is_empty():
     1503            res.append(self.left_rotate())
     1504        B = self.parent()._element_constructor_
     1505        return (res +
     1506                [B([g, self[1]]) for g in self[0].tamari_pred()] +
     1507                [B([self[0], d]) for d in self[1].tamari_pred()])
     1508
     1509    def tamari_smaller(self):
     1510        r"""
     1511        The list of all trees smaller or equal to ``self`` in the Tamari
     1512        order.
     1513        This is the transitive ideal of its predecessors.
     1514
     1515        The tree::
     1516
     1517            |     __o__   |
     1518            |    /     \  |
     1519            |   o       o |
     1520            |  / \     /  |
     1521            | o   o   o   |
     1522
     1523        has these trees smaller or equal to it::
     1524
     1525            |    __o__  ,       _o_  ,        o ,         o,         o,           o |
     1526            |   /     \        /   \         /           /          /            /  |
     1527            |  o       o      o     o      _o_          o          o            o   |
     1528            | / \     /      /     /      /   \        / \        /            /    |
     1529            |o   o   o      o     o      o     o      o   o      o            o     |
     1530            |              /            / \          /          /            /      |
     1531            |             o            o   o        o          o            o       |
     1532            |                                      /          / \          /        |
     1533            |                                     o          o   o        o         |
     1534            |                                                            /          |
     1535            |                                                           o           |
     1536
     1537        TESTS::
     1538
     1539            sage: B = BinaryTree
     1540            sage: b = B([None, B([None, B([None, B([])])])]);b
     1541            [., [., [., [., .]]]]
     1542            sage: b.tamari_smaller()
     1543            [[., [., [., [., .]]]], [., [., [[., .], .]]], [., [[., .], [., .]]], [., [[., [., .]], .]], [., [[[., .], .], .]], [[., .], [., [., .]]], [[., .], [[., .], .]], [[., [., .]], [., .]], [[., [., [., .]]], .], [[., [[., .], .]], .], [[[., .], .], [., .]], [[[., .], [., .]], .], [[[., [., .]], .], .], [[[[., .], .], .], .]]
     1544            sage: b = B([B([B([B([]), None]), None]), None]);b
     1545            [[[[., .], .], .], .]
     1546            sage: b.tamari_smaller()
     1547            [[[[[., .], .], .], .]]
     1548        """
     1549        from sage.combinat.tools import transitive_ideal
     1550        return transitive_ideal(lambda x: x.tamari_pred(), self)
     1551
     1552    def tamari_succ(self):
     1553        r"""
     1554        Compute the list of successors of ``self`` in the Tamari poset.
     1555        There is the list of all trees obtained by a right rotate of
     1556        one of its nodes.
     1557
     1558        The list of successors of::
     1559
     1560            |     __o__   |
     1561            |    /     \  |
     1562            |   o       o |
     1563            |  / \     /  |
     1564            | o   o   o   |
     1565
     1566        is::
     1567
     1568            |   _o__     ,   ___o___  ,     _o_     |
     1569            |  /    \       /       \      /   \    |
     1570            | o     _o_    o         o    o     o   |
     1571            |      /   \    \       /    / \     \  |
     1572            |     o     o    o     o    o   o     o |
     1573            |          /      \                     |
     1574            |         o        o                    |
     1575
     1576        TESTS::
     1577
     1578            sage: B = BinaryTree
     1579            sage: b = B([B([B([B([]), None]), None]), None]);b
     1580            [[[[., .], .], .], .]
     1581            sage: b.tamari_succ()
     1582            [[[[., .], .], [., .]], [[[., .], [., .]], .], [[[., [., .]], .], .]]
     1583
     1584            sage: b = B([])
     1585            sage: b.tamari_succ()
     1586            []
     1587
     1588            sage: b = B([[],[]])
     1589            sage: b.tamari_succ()
     1590            [[., [., [., .]]]]
     1591        """
     1592        res = []
     1593        if self.is_empty():
     1594            return []
     1595        B = self.parent()._element_constructor_
     1596        if not self[0].is_empty():
     1597            res.append(self.right_rotate())
     1598        return (res +
     1599             [B([g, self[1]]) for g in self[0].tamari_succ()] +
     1600             [B([self[0], d]) for d in self[1].tamari_succ()])
     1601
     1602    def q_hook_length_fraction(self, q=None, q_factor=False):
     1603        r"""
     1604        Compute the ``q``-hook length fraction of the binary tree ``self``,
     1605        with an additional "q-factor" if desired.
     1606
     1607        If `T` is a (plane) binary tree and `q` is a polynomial
     1608        indeterminate over some ring, then the `q`-hook length fraction
     1609        `h_{q} (T)` of `T` is defined by
     1610
     1611        .. MATH::
     1612
     1613            h_{q} (T)
     1614            = \frac{[\lvert T \rvert]_q!}{\prod_{t \in T}
     1615            [\lvert T_t \rvert]_q},
     1616
     1617        where the product ranges over all nodes `t` of `T`, where `T_t`
     1618        denotes the subtree of `T` consisting of `t` and its all
     1619        descendants, and where for every tree `S`, we denote by
     1620        `\lvert S \rvert` the number of nodes of `S`. While this
     1621        definition only shows that `h_{q} (T)` is a rational function
     1622        in `T`, it is in fact easy to show that `h_{q} (T)` is
     1623        actually a polynomial in `T`, and thus makes sense when any
     1624        element of a commutative ring is substituted for `q`.
     1625        This can also be explicitly seen from the following recursive
     1626        formula for `h_{q} (T)`:
     1627
     1628        .. MATH::
     1629
     1630            h_{q} (T)
     1631            = \binom{ \lvert T \rvert - 1 }{ \lvert T_1 \rvert }_q
     1632            h_{q} (T_1) h_{q} (T_2),
     1633
     1634        where `T` is any nonempty binary tree, and `T_1` and `T_2` are
     1635        the two children trees of the root of `T`, and where
     1636        `\binom{a}{b}_q` denotes a `q`-binomial coefficient.
     1637
     1638        A variation of the `q`-hook length fraction is the following
     1639        "`q`-hook length fraction with `q`-factor":
     1640
     1641        .. MATH::
     1642
     1643            f_{q} (T)
     1644            = h_{q} (T) \cdot
     1645            \prod_{t \in T} q^{\lvert T_{\mathrm{right}(t)} \rvert},
     1646
     1647        where for every node `t`, we denote by `\mathrm{right}(t)` the
     1648        right child of `t`.
     1649        This `f_{q} (T)` differs from `h_{q} (T)` only in a
     1650        multiplicative factor, which is a power of `q`.
     1651
     1652        When `q = 1`, both `f_{q} (T)` and `h_{q} (T)` equal the number
     1653        of permutations whose binary search tree (see [HNT05]_ for the
     1654        definition) is `T` (after dropping the labels). For example,
     1655        there are `20` permutations which give a binary tree of the
     1656        following shape::
     1657
     1658            |     __o__   |
     1659            |    /     \  |
     1660            |   o       o |
     1661            |  / \     /  |
     1662            | o   o   o   |
     1663
     1664        by the binary search insertion algorithm, in accordance with
     1665        the fact that this tree satisfies `f_{1} (T) = 20`.
     1666
     1667        When `q` is considered as a polynomial indeterminate,
     1668        `f_{q} (T)` is the generating function for all permutations
     1669        whose binary search tree is `T` (after dropping the labels)
     1670        with respect to the number of inversions (i. e., the Coxeter
     1671        length) of the permutations.
     1672
     1673        Objects similar to `h_{q} (T)` also make sense for general
     1674        ordered forests (rather than just binary trees), see e. g.
     1675        [BW88]_, Theorem 9.1.
     1676
     1677        INPUT:
     1678
     1679        - ``q`` -- a ring element which is to be substituted as `q`
     1680          into the `q`-hook length fraction (by default, this is
     1681          set to be the indeterminate `q` in the polynomial ring
     1682          `\ZZ[q]`)
     1683
     1684        - ``q_factor`` -- a Boolean (default: ``False``) which
     1685          determines whether to compute `h_{q} (T)` or to
     1686          compute `f_{q} (T)` (namely, `h_{q} (T)` is obtained when
     1687          ``q_factor == False``, and `f_{q} (T)` is obtained when
     1688          ``q_factor == True``)
     1689
     1690        REFERENCES:
     1691
     1692        .. [BW88] Anders Bjoerner, Michelle L. Wachs,
     1693           *Generalized quotients in Coxeter groups*.
     1694           Transactions of the American Mathematical Society,
     1695           vol. 308, no. 1, July 1988.
     1696           http://www.ams.org/journals/tran/1988-308-01/S0002-9947-1988-0946427-X/S0002-9947-1988-0946427-X.pdf
    10721697       
    1073 
     1698        EXAMPLES:
     1699
     1700        Let us start with a simple example. Actually, let us start
     1701        with the easiest possible example -- the binary tree with
     1702        only one vertex (which is a leaf)::
     1703
     1704            sage: b = BinaryTree()
     1705            sage: b.q_hook_length_fraction()
     1706            1
     1707            sage: b.q_hook_length_fraction(q_factor=True)
     1708            1
     1709
     1710        Nothing different for a tree with one node and two leaves::
     1711
     1712            sage: b = BinaryTree([]); b
     1713            [., .]
     1714            sage: b.q_hook_length_fraction()
     1715            1
     1716            sage: b.q_hook_length_fraction(q_factor=True)
     1717            1
     1718
     1719        Let us get to a more interesting tree::
     1720
     1721            sage: b = BinaryTree([[[],[]],[[],None]]); b
     1722            [[[., .], [., .]], [[., .], .]]
     1723            sage: b.q_hook_length_fraction()(q=1)
     1724            20
     1725            sage: b.q_hook_length_fraction()
     1726            q^7 + 2*q^6 + 3*q^5 + 4*q^4 + 4*q^3 + 3*q^2 + 2*q + 1
     1727            sage: b.q_hook_length_fraction(q_factor=True)
     1728            q^10 + 2*q^9 + 3*q^8 + 4*q^7 + 4*q^6 + 3*q^5 + 2*q^4 + q^3
     1729            sage: b.q_hook_length_fraction(q=2)
     1730            465
     1731            sage: b.q_hook_length_fraction(q=2, q_factor=True)
     1732            3720
     1733            sage: q = PolynomialRing(ZZ, 'q').gen()
     1734            sage: b.q_hook_length_fraction(q=q**2)
     1735            q^14 + 2*q^12 + 3*q^10 + 4*q^8 + 4*q^6 + 3*q^4 + 2*q^2 + 1
     1736
     1737        Let us check the fact that `f_{q} (T)` is the generating function
     1738        for all permutations whose binary search tree is `T` (after
     1739        dropping the labels) with respect to the number of inversions of
     1740        the permutations::
     1741
     1742            sage: def q_hook_length_fraction_2(T):
     1743            ....:     P = PolynomialRing(ZZ, 'q')
     1744            ....:     q = P.gen()
     1745            ....:     res = P.zero()
     1746            ....:     for w in T.sylvester_class():
     1747            ....:         res += q ** Permutation(w).length()
     1748            ....:     return res
     1749            sage: def test_genfun(i):
     1750            ....:     return all( q_hook_length_fraction_2(T)
     1751            ....:                 == T.q_hook_length_fraction(q_factor=True)
     1752            ....:                 for T in BinaryTrees(i) )
     1753            sage: test_genfun(4)
     1754            True
     1755            sage: test_genfun(7)  # long time
     1756            True
     1757        """
     1758        from sage.combinat.q_analogues import q_binomial
     1759
     1760        if q is None:
     1761            from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
     1762            from sage.rings.integer_ring import ZZ
     1763            basering = PolynomialRing(ZZ, 'q')
     1764            q = basering.gen()
     1765        else:
     1766            basering = q.base_ring()
     1767
     1768        if q_factor:
     1769            def product_of_subtrees(b):
     1770                if b.is_empty():
     1771                    return basering.one()
     1772                b0 = b[0]
     1773                b1 = b[1]
     1774                return q_binomial(b.node_number() - 1, b0.node_number(), q=q) * \
     1775                    product_of_subtrees(b0) * product_of_subtrees(b1) * \
     1776                    q ** (b1.node_number())
     1777        else:
     1778            def product_of_subtrees(b):
     1779                if b.is_empty():
     1780                    return basering.one()
     1781                b0 = b[0]
     1782                b1 = b[1]
     1783                return q_binomial(b.node_number() - 1, b0.node_number(), q=q) * \
     1784                    product_of_subtrees(b0) * product_of_subtrees(b1)
     1785
     1786        return product_of_subtrees(self)
     1787
     1788    @combinatorial_map(name="Right rotate")
     1789    def right_rotate(self):
     1790        r"""
     1791        Return the result of right rotation applied to the binary
     1792        tree ``self``.
     1793
     1794        Right rotation on binary trees is defined as follows:
     1795        Let `T` be a nonempty binary tree such that the left
     1796        child of the root of `T` is a node. Let `C` be the right
     1797        child of the root of `T`, and let `A` and `B` be the
     1798        left and right children of the left child of the root
     1799        of `T`. (Keep in mind that nodes of trees are identified
     1800        with the subtrees consisting of their descendants.)
     1801        Then, the right rotation of `T` is the nonempty binary
     1802        tree in which the left child of the root is `A`, whereas
     1803        the right child of the root is a node whose left and right
     1804        children are `B` and `C`. In pictures::
     1805
     1806            |     *                      *     |
     1807            |    / \                    / \    |
     1808            |   *   C -right-rotate->  A   *   |
     1809            |  / \                        / \  |
     1810            | A   B                      B   C |
     1811
     1812        where asterisks signify a single node each (but `A`, `B`
     1813        and `C` might be empty).
     1814
     1815        For example, ::
     1816
     1817            |     o                     _o_   |
     1818            |    /                     /   \  |
     1819            |   o    -right-rotate->  o     o |
     1820            |  / \                         /  |
     1821            | o   o                       o   |
     1822            <BLANKLINE>
     1823            |       __o__                         _o__      |
     1824            |      /     \                       /    \     |
     1825            |     o       o  -right-rotate->    o     _o_   |
     1826            |    / \                           /     /   \  |
     1827            |   o   o                         o     o     o |
     1828            |  /     \                               \      |
     1829            | o       o                               o     |
     1830
     1831        Right rotation is the inverse operation to left rotation
     1832        (:meth:`left_rotate`).
     1833
     1834        The right rotation operation introduced here is the one defined
     1835        in Definition 2.1 of [CP12]_.
     1836
     1837        .. SEEALSO::
     1838
     1839            :meth:`left_rotate`
     1840
     1841        EXAMPLES::
     1842
     1843            sage: b = BinaryTree([[[],[]], None]); ascii_art([b])
     1844            [     o ]
     1845            [    /  ]
     1846            [   o   ]
     1847            [  / \  ]
     1848            [ o   o ]
     1849            sage: ascii_art([b.right_rotate()])
     1850            [   _o_   ]
     1851            [  /   \  ]
     1852            [ o     o ]
     1853            [      /  ]
     1854            [     o   ]
     1855            sage: b = BinaryTree([[[[],None],[None,[]]], []]); ascii_art([b])
     1856            [       __o__   ]
     1857            [      /     \  ]
     1858            [     o       o ]
     1859            [    / \        ]
     1860            [   o   o       ]
     1861            [  /     \      ]
     1862            [ o       o     ]
     1863            sage: ascii_art([b.right_rotate()])
     1864            [     _o__      ]
     1865            [    /    \     ]
     1866            [   o     _o_   ]
     1867            [  /     /   \  ]
     1868            [ o     o     o ]
     1869            [        \      ]
     1870            [         o     ]
     1871        """
     1872        B = self.parent()._element_constructor_
     1873        return B([self[0][0], B([self[0][1], self[1]])])
     1874
     1875    @combinatorial_map(name="Left rotate")
     1876    def left_rotate(self):
     1877        r"""
     1878        Return the result of left rotation applied to the binary
     1879        tree ``self``.
     1880
     1881        Left rotation on binary trees is defined as follows:
     1882        Let `T` be a nonempty binary tree such that the right
     1883        child of the root of `T` is a node. Let `A` be the left
     1884        child of the root of `T`, and let `B` and `C` be the
     1885        left and right children of the right child of the root
     1886        of `T`. (Keep in mind that nodes of trees are identified
     1887        with the subtrees consisting of their descendants.)
     1888        Then, the left rotation of `T` is the nonempty binary
     1889        tree in which the right child of the root is `C`, whereas
     1890        the left child of the root is a node whose left and right
     1891        children are `A` and `B`. In pictures::
     1892
     1893            |   *                        *   |
     1894            |  / \                      / \  |
     1895            | A   *  -left-rotate->    *   C |
     1896            |    / \                  / \    |
     1897            |   B   C                A   B   |
     1898
     1899        where asterisks signify a single node each (but `A`, `B`
     1900        and `C` might be empty).
     1901
     1902        For example, ::
     1903
     1904            |   _o_                        o |
     1905            |  /   \                      /  |
     1906            | o     o  -left-rotate->    o   |
     1907            |      /                    / \  |
     1908            |     o                    o   o |
     1909            <BLANKLINE>
     1910            |       __o__                            o |
     1911            |      /     \                          /  |
     1912            |     o       o  -left-rotate->        o   |
     1913            |    / \                              /    |
     1914            |   o   o                            o     |
     1915            |  /     \                          / \    |
     1916            | o       o                        o   o   |
     1917            |                                 /     \  |
     1918            |                                o       o |
     1919
     1920        Left rotation is the inverse operation to right rotation
     1921        (:meth:`right_rotate`).
     1922
     1923        .. SEEALSO::
     1924
     1925            :meth:`right_rotate`
     1926
     1927        EXAMPLES::
     1928
     1929            sage: b = BinaryTree([[],[[],None]]); ascii_art([b])
     1930            [   _o_   ]
     1931            [  /   \  ]
     1932            [ o     o ]
     1933            [      /  ]
     1934            [     o   ]
     1935            sage: ascii_art([b.left_rotate()])
     1936            [     o ]
     1937            [    /  ]
     1938            [   o   ]
     1939            [  / \  ]
     1940            [ o   o ]
     1941            sage: b.left_rotate().right_rotate() == b
     1942            True
     1943        """
     1944        B = self.parent()._element_constructor_
     1945        return B([B([self[0], self[1][0]]), self[1][1]])
     1946
     1947    @combinatorial_map(name="Over operation on Binary Trees")
     1948    def over(self, bt):
     1949        r"""
     1950        Return ``self`` over ``bt``, where "over" is the ``over`` (`/`)
     1951        operation defined by Loday-Ronco [LodayRonco]_.
     1952
     1953        If `T` and `T'` are two binary trees, then `T` over `T'`
     1954        (written `T / T'`) is defined as the tree obtained by grafting
     1955        `T'` on the rightmost node of `T`. See section 4.5 of [HNT05]_.
     1956
     1957        .. TODO::
     1958
     1959            Fix this doc and figure out which of the different
     1960            (inconsistent?) notations to follow. I don't see the
     1961            "over" operation defined in [LodayRonco]_, although
     1962            [HNT05]_ pretends that it is defined there. In
     1963            [HNT05]_ the definition is somewhat vague about the
     1964            order of the operads. Loday and Ronco seem to define
     1965            "over" on page 2 of "Order structure on the algebra
     1966            of permutations and of planar binary trees", but
     1967            with a different choice of left/right.
     1968
     1969        This is defined by::
     1970
     1971            |   o       __o__       _o_         |
     1972            |  / \  /  /     \  =  /   \        |
     1973            | o   o   o       o   o     o       |
     1974            |          \     /           \      |
     1975            |           o   o           __o__   |
     1976            |                          /     \  |
     1977            |                         o       o |
     1978            |                          \     /  |
     1979            |                           o   o   |
     1980
     1981        EXAMPLES::
     1982
     1983            sage: b1 = BinaryTree([[],[[],[]]])
     1984            sage: b2 = BinaryTree([[None, []],[]])
     1985            sage: ascii_art((b1, b2, b1/b2))
     1986            (   _o_        _o_      _o_           )
     1987            (  /   \      /   \    /   \          )
     1988            ( o     o    o     o  o     o_        )
     1989            (      / \    \            /  \       )
     1990            (     o   o,   o    ,     o    o      )
     1991            (                               \     )
     1992            (                               _o_   )
     1993            (                              /   \  )
     1994            (                             o     o )
     1995            (                              \      )
     1996            (                               o     )
     1997
     1998        TESTS::
     1999
     2000            sage: b1 = BinaryTree([[],[]]); ascii_art([b1])
     2001            [   o   ]
     2002            [  / \  ]
     2003            [ o   o ]
     2004            sage: b2 = BinaryTree([[None,[]],[[],None]]); ascii_art([b2])
     2005            [   __o__   ]
     2006            [  /     \  ]
     2007            [ o       o ]
     2008            [  \     /  ]
     2009            [   o   o   ]
     2010            sage: ascii_art([b1.over(b2)])
     2011            [   _o_         ]
     2012            [  /   \        ]
     2013            [ o     o       ]
     2014            [        \      ]
     2015            [       __o__   ]
     2016            [      /     \  ]
     2017            [     o       o ]
     2018            [      \     /  ]
     2019            [       o   o   ]
     2020        """
     2021        B = self.parent()._element_constructor_
     2022        if self.is_empty():
     2023            return bt
     2024        lab = None
     2025        if hasattr(self, "label"):
     2026            lab = self.label()
     2027        else:
     2028            return B([self[0], self[1].over(bt)], lab)
     2029
     2030    __div__ = over
     2031
     2032    @combinatorial_map(name="Under operation on Binary Trees")
     2033    def under(self, bt):
     2034        r"""
     2035        The ``under`` (`\backslash`) operation defined by Loday-Ronco
     2036        [LodayRonco]_.
     2037
     2038        EXAMPLES::
     2039
     2040            sage: b1 = BinaryTree([[],[]])
     2041            sage: b2 = BinaryTree([None,[]])
     2042            sage: ascii_art((b1, b2, b1 \ b2))
     2043            (   o    o        _o_   )
     2044            (  / \    \      /   \  )
     2045            ( o   o,   o,   o     o )
     2046            (              / \      )
     2047            (             o   o     )
     2048
     2049        TESTS::
     2050
     2051            sage: b1 = BinaryTree([[],[[None,[]],None]]); ascii_art([b1])
     2052            [   _o_   ]
     2053            [  /   \  ]
     2054            [ o     o ]
     2055            [      /  ]
     2056            [     o   ]
     2057            [      \  ]
     2058            [       o ]
     2059            sage: b2 = BinaryTree([[],[None,[]]]); ascii_art([b2])
     2060            [   o     ]
     2061            [  / \    ]
     2062            [ o   o   ]
     2063            [      \  ]
     2064            [       o ]
     2065            sage: ascii_art([b1.under(b2)])
     2066            [        o_     ]
     2067            [       /  \    ]
     2068            [      o    o   ]
     2069            [     /      \  ]
     2070            [   _o_       o ]
     2071            [  /   \        ]
     2072            [ o     o       ]
     2073            [      /        ]
     2074            [     o         ]
     2075            [      \        ]
     2076            [       o       ]
     2077        """
     2078        B = self.parent()._element_constructor_
     2079        if bt.is_empty():
     2080            return self
     2081        lab = None
     2082        if hasattr(bt, "label"):
     2083            lab = bt.label()
     2084        else:
     2085            return B([self.under(bt[0]), bt[1]], lab)
     2086
     2087    _backslash_ = under
     2088
     2089    def sylvester_class(self, left_to_right=False):
     2090        r"""
     2091        Iterate over the sylvester class corresponding to the binary tree
     2092        ``self``.
     2093
     2094        The sylvester class of a tree `T` is the set of permutations
     2095        `\sigma` whose binary search tree (a notion defined in [HNT05]_,
     2096        Definition 7) is `T` after forgetting the labels. This is an
     2097        equivalence class of the sylvester congruence (the congruence on
     2098        words which sets two words `uacvbw` and `ucavbw` congruent
     2099        whenever `a`, `b`, `c` are letters satisfying `a \leq b < c`, and
     2100        extends by transitivity) on the symmetric group.
     2101
     2102        For example the following tree's sylvester class consists of the
     2103        permutations `(1,3,2)` and `(3,1,2)`::
     2104
     2105            [   o   ]
     2106            [  / \  ]
     2107            [ o   o ]
     2108
     2109        (only the nodes are drawn here).
     2110
     2111        The binary search tree of a word is constructed by an RSK-like
     2112        algorithm, in which the word is read from right to left. If a
     2113        left-to-right reading is to be employed instead, the
     2114        ``left_to_right`` optional keyword variable should be set to
     2115        ``True``.
     2116
     2117        TESTS::
     2118
     2119            sage: list(BinaryTree([[],[]]).sylvester_class())
     2120            [[1, 3, 2], [3, 1, 2]]
     2121            sage: bt = BinaryTree([[[],None],[[],[]]])
     2122            sage: l = list(bt.sylvester_class()); l
     2123            [[1, 2, 4, 6, 5, 3],
     2124             [1, 4, 2, 6, 5, 3],
     2125             [1, 4, 6, 2, 5, 3],
     2126             [1, 4, 6, 5, 2, 3],
     2127             [4, 1, 2, 6, 5, 3],
     2128             [4, 1, 6, 2, 5, 3],
     2129             [4, 1, 6, 5, 2, 3],
     2130             [4, 6, 1, 2, 5, 3],
     2131             [4, 6, 1, 5, 2, 3],
     2132             [4, 6, 5, 1, 2, 3],
     2133             [1, 2, 6, 4, 5, 3],
     2134             [1, 6, 2, 4, 5, 3],
     2135             [1, 6, 4, 2, 5, 3],
     2136             [1, 6, 4, 5, 2, 3],
     2137             [6, 1, 2, 4, 5, 3],
     2138             [6, 1, 4, 2, 5, 3],
     2139             [6, 1, 4, 5, 2, 3],
     2140             [6, 4, 1, 2, 5, 3],
     2141             [6, 4, 1, 5, 2, 3],
     2142             [6, 4, 5, 1, 2, 3]]
     2143            sage: len(l) == Integer(bt.q_hook_length_fraction()(q=1))
     2144            True
     2145
     2146        Border cases::
     2147
     2148            sage: list(BinaryTree().sylvester_class())
     2149            [[]]
     2150            sage: list(BinaryTree([]).sylvester_class())
     2151            [[1]]
     2152        """
     2153        if self.is_empty():
     2154            yield []
     2155            return
     2156        import itertools
     2157        from sage.combinat.words.word import Word as W
     2158        from sage.combinat.words.shuffle_product import ShuffleProduct_w1w2 \
     2159            as shuffle
     2160
     2161        if left_to_right:
     2162            builder = lambda i, p: [i] + list(p)
     2163        else:
     2164            builder = lambda i, p: list(p) + [i]
     2165
     2166        shift = self[0].node_number() + 1
     2167        for l, r in itertools.product(
     2168                    self[0].sylvester_class(),
     2169                    self[1].sylvester_class()):
     2170           for p in shuffle(W(l), W([shift + ri for ri in r])):
     2171               yield builder(shift, p)
     2172
     2173    def is_full(self):
     2174        r"""
     2175        Return ``True`` if ``self`` is full, else return ``False``.
     2176
     2177        A full binary tree is a tree in which every node either has two
     2178        child nodes or has two child leaves.
     2179
     2180        This is also known as *proper binary tree* or *2-tree* or *strictly
     2181        binary tree*.
     2182
     2183        For example::
     2184
     2185            |       __o__   |
     2186            |      /     \  |
     2187            |     o       o |
     2188            |    / \        |
     2189            |   o   o       |
     2190            |  /     \      |
     2191            | o       o     |
     2192
     2193        is not full but the next one is::
     2194
     2195            |         ___o___   |
     2196            |        /       \  |
     2197            |     __o__       o |
     2198            |    /     \        |
     2199            |   o       o       |
     2200            |  / \     / \      |
     2201            | o   o   o   o     |
     2202
     2203        EXAMPLES::
     2204
     2205            sage: BinaryTree([[[[],None],[None,[]]], []]).is_full()
     2206            False
     2207            sage: BinaryTree([[[[],[]],[[],[]]], []]).is_full()
     2208            True
     2209            sage: ascii_art(filter(lambda bt: bt.is_full(), BinaryTrees(5)))
     2210            [   _o_          _o_   ]
     2211            [  /   \        /   \  ]
     2212            [ o     o      o     o ]
     2213            [      / \    / \      ]
     2214            [     o   o, o   o     ]
     2215        """
     2216        if self.is_empty():
     2217            return True
     2218        if self[0].is_empty() != self[1].is_empty():
     2219            return False
     2220        return self[0].is_full() and self[1].is_full()
     2221
     2222    def is_perfect(self):
     2223        r"""
     2224        Return ``True`` if ``self`` is perfect, else return ``False``.
     2225
     2226        A perfect binary tree is a full tree in which all leaves are at the
     2227        same depth.
     2228
     2229        For example::
     2230
     2231            |         ___o___   |
     2232            |        /       \  |
     2233            |     __o__       o |
     2234            |    /     \        |
     2235            |   o       o       |
     2236            |  / \     / \      |
     2237            | o   o   o   o     |
     2238
     2239        is not perfect but the next one is::
     2240
     2241            |     __o__     |
     2242            |    /     \    |
     2243            |   o       o   |
     2244            |  / \     / \  |
     2245            | o   o   o   o |
     2246
     2247        EXAMPLES::
     2248
     2249            sage: lst = lambda i: filter(lambda bt: bt.is_perfect(), BinaryTrees(i))
     2250            sage: for i in range(10): ascii_art(lst(i)) # long time
     2251            [  ]
     2252            [ o ]
     2253            [  ]
     2254            [   o   ]
     2255            [  / \  ]
     2256            [ o   o ]
     2257            [  ]
     2258            [  ]
     2259            [  ]
     2260            [     __o__     ]
     2261            [    /     \    ]
     2262            [   o       o   ]
     2263            [  / \     / \  ]
     2264            [ o   o   o   o ]
     2265            [  ]
     2266            [  ]
     2267        """
     2268        return 2 ** self.depth() - 1 == self.node_number()
     2269
     2270    def is_complete(self):
     2271        r"""
     2272        Return ``True`` if ``self`` is complete, else return ``False``.
     2273
     2274        A complete binary tree is a perfect binary tree except possibly in the
     2275        last level.
     2276
     2277        A complete binary tree (also called binary heap) is a binary tree in
     2278        which every level, except possibly the last one (the deepest), is
     2279        completely filled. At depth `n` all nodes must be as far left as
     2280        possible.
     2281
     2282        For example::
     2283
     2284            |         ___o___   |
     2285            |        /       \  |
     2286            |     __o__       o |
     2287            |    /     \        |
     2288            |   o       o       |
     2289            |  / \     / \      |
     2290            | o   o   o   o     |
     2291
     2292        is not complete but the following ones are::
     2293
     2294            |     __o__          _o_            ___o___     |
     2295            |    /     \        /   \          /       \    |
     2296            |   o       o      o     o      __o__       o   |
     2297            |  / \     / \    / \          /     \     / \  |
     2298            | o   o   o   o, o   o    ,   o       o   o   o |
     2299            |                            / \     /          |
     2300            |                           o   o   o           |
     2301
     2302        EXAMPLES::
     2303
     2304            sage: lst = lambda i: filter(lambda bt: bt.is_complete(), BinaryTrees(i))
     2305            sage: for i in range(9): ascii_art(lst(i)) # long time
     2306            [  ]
     2307            [ o ]
     2308            [   o ]
     2309            [  /  ]
     2310            [ o   ]
     2311            [   o   ]
     2312            [  / \  ]
     2313            [ o   o ]
     2314            [     o   ]
     2315            [    / \  ]
     2316            [   o   o ]
     2317            [  /      ]
     2318            [ o       ]
     2319            [     _o_   ]
     2320            [    /   \  ]
     2321            [   o     o ]
     2322            [  / \      ]
     2323            [ o   o     ]
     2324            [     __o__   ]
     2325            [    /     \  ]
     2326            [   o       o ]
     2327            [  / \     /  ]
     2328            [ o   o   o   ]
     2329            [     __o__     ]
     2330            [    /     \    ]
     2331            [   o       o   ]
     2332            [  / \     / \  ]
     2333            [ o   o   o   o ]
     2334            [       __o__     ]
     2335            [      /     \    ]
     2336            [     o       o   ]
     2337            [    / \     / \  ]
     2338            [   o   o   o   o ]
     2339            [  /              ]
     2340            [ o               ]
     2341        """
     2342        if self.is_empty():
     2343            return True
     2344        # self := L ^ R
     2345        dL = self[0].depth()
     2346        dR = self[1].depth()
     2347        # if L is perfect
     2348        if self[0].is_perfect():
     2349            # if the depth of R == depth of L then R must be complete
     2350            if dL == dR:
     2351                return self[1].is_complete()
     2352            # else R is perfect with depth equals depth of L - 1
     2353            elif dL == dR + 1:
     2354                return self[1].is_perfect()
     2355            return False
     2356        # L is not perfect then R is perfect and the depth of L = the depth of
     2357        # R + 1
     2358        return self[0].is_complete() and self[1].is_perfect() and dL == dR + 1
    10742359
    10752360from sage.structure.parent import Parent
    10762361from sage.structure.unique_representation import UniqueRepresentation
    class BinaryTrees(UniqueRepresentation,  
    11312416            return BinaryTrees_all()
    11322417        else:
    11332418            if not (isinstance(n, (Integer, int)) and n >= 0):
    1134                 raise ValueError("n must be a non negative integer")
     2419                raise ValueError("n must be a nonnegative integer")
    11352420            return BinaryTrees_size(Integer(n))
    11362421
    11372422    @cached_method
    class BinaryTrees_all(DisjointUnionEnume 
    11762461
    11772462            sage: B is BinaryTrees_all()
    11782463            True
    1179             sage: TestSuite(B).run()
     2464            sage: TestSuite(B).run() # long time
    11802465            """
    11812466        DisjointUnionEnumeratedSets.__init__(
    11822467            self, Family(NonNegativeIntegers(), BinaryTrees_size),
    class BinaryTrees_size(BinaryTrees): 
    14002685
    14012686class LabelledBinaryTree(AbstractLabelledClonableTree, BinaryTree):
    14022687    """
    1403     The class of labelled binary tree
     2688    Labelled binary trees.
     2689
     2690    A labelled binary tree is a binary tree (see :class:`BinaryTree` for
     2691    the meaning of this) with a label assigned to each node. (The labels
     2692    need not be integers, nor are they required to be distinct. ``None``
     2693    can be used as a label.)
     2694
     2695    .. TODO::
     2696
     2697        Explain how to init these.
     2698
     2699        Maybe allow ``LabelledBinaryTree()`` syntax for
     2700        ``LabelledBinaryTree(None)`` (in analogy to ``BinaryTree``
     2701        class).
    14042702
    14052703    EXAMPLE::
    14062704
    class LabelledBinaryTree(AbstractLabelle 
    14312729    @lazy_class_attribute
    14322730    def _auto_parent(cls):
    14332731        """
    1434         The automatic parent of the element of this class
     2732        The automatic parent of the elements of this class.
    14352733
    14362734        When calling the constructor of an element of this class, one needs a
    14372735        parent. This class attribute specifies which parent is used.
    class LabelledBinaryTree(AbstractLabelle 
    14652763
    14662764    def binary_search_insert(self, letter):
    14672765        """
    1468         Insert a letter in a binary search tree
     2766        Return the result of inserting a letter ``letter`` into the
     2767        right strict binary search tree ``self``.
    14692768
    14702769        INPUT:
    14712770
    14722771        - ``letter`` -- any object comparable with the label of ``self``
    14732772
     2773        OUTPUT:
     2774
     2775        The right strict binary search tree ``self`` with ``letter``
     2776        inserted into it according to the binary search insertion
     2777        algorithm.
     2778
    14742779        .. NOTE:: ``self`` is supposed to be a binary search tree. No check is
    14752780                  performed.
    14762781
     2782        A right strict binary search tree is defined to be a labelled
     2783        binary tree such that for each node `n` with label `x`,
     2784        every descendant of the left child of `n` has a label `\leq x`,
     2785        and every descendant of the right child of `n` has a label
     2786        `> x`. (Here, only nodes count as descendants, and every node
     2787        counts as its own descendant too.)
     2788
     2789        .. TODO::
     2790
     2791            Explain the algorithm.
     2792
    14772793        EXAMPLES::
    14782794
    14792795            sage: LBT = LabelledBinaryTree
    class LabelledBinaryTree(AbstractLabelle 
    14852801            3[1[., .], .]
    14862802            sage: res = LBT(None)
    14872803            sage: for i in [3,1,5,2,4,6]:
    1488             ...       res = res.binary_search_insert(i)
     2804            ....:     res = res.binary_search_insert(i)
    14892805            sage: res
    14902806            3[1[., 2[., .]], 5[4[., .], 6[., .]]]
    14912807        """
    class LabelledBinaryTree(AbstractLabelle 
    15002816                fils = self[1].binary_search_insert(letter)
    15012817                return LT([self[0], fils], label=self.label())
    15022818
     2819    def right_rotate(self):
     2820        r"""
     2821        Return the result of right rotation applied to the labelled
     2822        binary tree ``self``.
     2823
     2824        Right rotation on labelled binary trees is defined as
     2825        follows: Let `T` be a nonempty labelled binary tree such
     2826        that the left child of the root of `T` is a node. Let
     2827        `C` be the right child of the root of `T`, and let `A`
     2828        and `B` be the left and right children of the left child
     2829        of the root of `T`. (Keep in mind that nodes of trees are
     2830        identified with the subtrees consisting of their
     2831        descendants.) Furthermore, let `y` be the label at the
     2832        root of `T`, and `x` be the label at the left child of the
     2833        root of `T`.
     2834        Then, the right rotation of `T` is the nonempty labelled
     2835        binary tree in which the root is labelled `x`, the left
     2836        child of the root is `A`, whereas the right child of the
     2837        root is a node labelled `y` whose left and right children
     2838        are `B` and `C`. In pictures::
     2839
     2840            |     y                      x     |
     2841            |    / \                    / \    |
     2842            |   x   C -right-rotate->  A   y   |
     2843            |  / \                        / \  |
     2844            | A   B                      B   C |
     2845
     2846        Right rotation is the inverse operation to left rotation
     2847        (:meth:`left_rotate`).
     2848
     2849        TESTS::
     2850
     2851            sage: LB = LabelledBinaryTree
     2852            sage: b = LB([LB([LB([],"A"), LB([],"B")],"x"),LB([],"C")], "y"); b
     2853            y[x[A[., .], B[., .]], C[., .]]
     2854            sage: b.right_rotate()
     2855            x[A[., .], y[B[., .], C[., .]]]
     2856        """
     2857        B = self.parent()._element_constructor_
     2858        return B([
     2859            self[0][0],
     2860            B([self[0][1], self[1]], self.label())
     2861        ], self[0].label())
     2862
     2863    def left_rotate(self):
     2864        r"""
     2865        Return the result of left rotation applied to the labelled
     2866        binary tree ``self``.
     2867
     2868        Left rotation on labelled binary trees is defined as
     2869        follows: Let `T` be a nonempty labelled binary tree such
     2870        that the right child of the root of `T` is a node. Let
     2871        `A` be the left child of the root of `T`, and let `B`
     2872        and `C` be the left and right children of the right child
     2873        of the root of `T`. (Keep in mind that nodes of trees are
     2874        identified with the subtrees consisting of their
     2875        descendants.) Furthermore, let `x` be the label at the
     2876        root of `T`, and `y` be the label at the right child of the
     2877        root of `T`.
     2878        Then, the left rotation of `T` is the nonempty labelled
     2879        binary tree in which the root is labelled `y`, the right
     2880        child of the root is `C`, whereas the left child of the
     2881        root is a node labelled `x` whose left and right children
     2882        are `A` and `B`. In pictures::
     2883
     2884           |     y                    x     |
     2885           |    / \                  / \    |
     2886           |   x   C <-left-rotate- A   y   |
     2887           |  / \                      / \  |
     2888           | A   B                    B   C |
     2889
     2890        Left rotation is the inverse operation to right rotation
     2891        (:meth:`right_rotate`).
     2892
     2893        TESTS::
     2894
     2895            sage: LB = LabelledBinaryTree
     2896            sage: b = LB([LB([LB([],"A"), LB([],"B")],"x"),LB([],"C")], "y"); b
     2897            y[x[A[., .], B[., .]], C[., .]]
     2898            sage: b == b.right_rotate().left_rotate()
     2899            True
     2900        """
     2901        B = self.parent()._element_constructor_
     2902        return B([
     2903            B([self[0], self[1][0]], self.label()),
     2904            self[1][1]
     2905        ], self[1].label())
     2906
     2907    def heap_insert(self, l):
     2908        r"""
     2909        Return the result of inserting a letter ``l`` into the binary
     2910        heap (tree) ``self``.
     2911
     2912        Roughly, a binary heap will be a labelled complete binary tree
     2913        such that for each node the label is greater or equal to the
     2914        label of each of its children.
     2915
     2916        For example::
     2917
     2918            |     _7_   |
     2919            |    /   \  |
     2920            |   5     6 |
     2921            |  / \      |
     2922            | 3   4     |
     2923
     2924        is a binary heap.
     2925
     2926        INPUT:
     2927
     2928        - ``letter`` -- any object comparable with the label of ``self``
     2929
     2930        .. NOTE::
     2931
     2932            ``self`` is assumed to be a binary heap (tree). No check is
     2933            performed.
     2934
     2935        TESTS::
     2936
     2937            sage: h = LabelledBinaryTree(None)
     2938            sage: h = h.heap_insert(3); ascii_art([h])
     2939            [ 3 ]
     2940            sage: h = h.heap_insert(4); ascii_art([h])
     2941            [   4 ]
     2942            [  /  ]
     2943            [ 3   ]
     2944            sage: h = h.heap_insert(6); ascii_art([h])
     2945            [   6   ]
     2946            [  / \  ]
     2947            [ 3   4 ]
     2948            sage: h = h.heap_insert(2); ascii_art([h])
     2949            [     6   ]
     2950            [    / \  ]
     2951            [   3   4 ]
     2952            [  /      ]
     2953            [ 2       ]
     2954            sage: ascii_art([h.heap_insert(5)])
     2955            [     _6_   ]
     2956            [    /   \  ]
     2957            [   5     4 ]
     2958            [  / \      ]
     2959            [ 2   3     ]
     2960        """
     2961        B = self.parent()._element_constructor_
     2962        if self.is_empty():
     2963            return B([], l)
     2964
     2965        if self.label() < l:
     2966            label_root = l
     2967            label_insert = self.label()
     2968        else:
     2969            label_root = self.label()
     2970            label_insert = l
     2971        L, R = self
     2972        dL = L.depth()
     2973        dR = R.depth()
     2974        # if depth of L is greater than the depth of R
     2975        if dL > dR:
     2976            # if L is perfect we insert in R
     2977            if L.is_perfect():
     2978                return B([L, R.heap_insert(label_insert)], label_root)
     2979            # we insert in L
     2980            return B([L.heap_insert(label_insert), R], label_root)
     2981        # else ==> dL == dR
     2982        # if R is perfect we have to insert on the most left leaf
     2983        if R.is_perfect():
     2984            # ## TODO:: can be optimized...
     2985            return B([L.heap_insert(label_insert), R], label_root)
     2986        # else we insert on the right
     2987        return B([L, R.heap_insert(label_insert)], label_root)
     2988
    15032989    _UnLabelled = BinaryTree
    15042990
    15052991
  • sage/combinat/ordered_tree.py

    diff --git a/sage/combinat/ordered_tree.py b/sage/combinat/ordered_tree.py
    a b from sage.combinat.combinatorial_map imp 
    2626
    2727class OrderedTree(AbstractClonableTree, ClonableList):
    2828    """
    29     The class for (ordered rooted) Trees
     29    The class of (ordered rooted) trees.
    3030
    31     An ordered tree is constructed from a node called the root on which one
     31    An ordered tree is constructed from a node, called the root, on which one
    3232    has grafted a possibly empty list of trees. There is a total order on the
    3333    children of a node which is given by the order of the elements in the
    34     list. Note that there is no empty ordered tree.
     34    list. Note that there is no empty ordered tree (so the smallest ordered
     35    tree consists of just one node).
    3536
    3637    INPUT:
    3738
    class OrderedTree(AbstractClonableTree,  
    6263        sage: tt1.__hash__() == tt2.__hash__()
    6364        True
    6465
    65     Trees are usually immutable. However they inherits from
    66     :class:`sage.structure.list_clone.ClonableList`. So that they can be
    67     modified using the clone protocol:
     66    Trees are usually immutable. However they inherit from
     67    :class:`sage.structure.list_clone.ClonableList`, so that they can be
     68    modified using the clone protocol. Let us now see what this means.
    6869
    69     Trying to modify a non mutable tree raises an error::
     70    Trying to modify a non-mutable tree raises an error::
    7071
    7172        sage: tt1[1] = tt2
    7273        Traceback (most recent call last):
    class OrderedTree(AbstractClonableTree,  
    7677    Here is the correct way to do it::
    7778
    7879        sage: with tt2.clone() as tt2:
    79         ...    tt2[1] = tt1
     80        ....:     tt2[1] = tt1
    8081        sage: tt2
    8182        [[], [[], [[], []], [[], []]], [[], []]]
    8283
    8384    It is also possible to append a child to a tree::
    8485
    8586        sage: with tt2.clone() as tt3:
    86         ...    tt3.append(OrderedTree([]))
     87        ....:     tt3.append(OrderedTree([]))
    8788        sage: tt3
    8889        [[], [[], [[], []], [[], []]], [[], []], []]
    8990
    9091    Or to insert a child in a tree::
    9192
    9293        sage: with tt2.clone() as tt3:
    93         ...    tt3.insert(2, OrderedTree([]))
     94        ....:     tt3.insert(2, OrderedTree([]))
    9495        sage: tt3
    9596        [[], [[], [[], []], [[], []]], [], [[], []]]
    9697
    class OrderedTree(AbstractClonableTree,  
    108109
    109110        sage: tt1bis = OrderedTree(tt1)
    110111        sage: with tt1.clone() as tt1:
    111         ...    tt1[1] = tt1bis
     112        ....:     tt1[1] = tt1bis
    112113        sage: tt1
    113114        [[], [[], [[], []], [[], []]], [[], []]]
    114115        sage: tt1 == tt2
    class OrderedTree(AbstractClonableTree,  
    159160    Check that the hash value is correctly updated after modification::
    160161
    161162        sage: with tt2.clone() as tt2:
    162         ...    tt2[1,1] = tt1
     163        ....:     tt2[1,1] = tt1
    163164        sage: tt1.__hash__() == tt2.__hash__()
    164165        False
    165166    """
    class OrderedTree(AbstractClonableTree,  
    246247
    247248    def is_empty(self):
    248249        """
    249         Return if ``self`` is the empty tree
     250        Return if ``self`` is the empty tree.
    250251
    251         For ordered trees, returns always ``False``
     252        For ordered trees, returns always ``False``.
    252253
    253254        .. NOTE:: this is different from ``bool(t)`` which returns whether
    254255                  ``t`` has some child or not.
  • sage/misc/latex.py

    diff --git a/sage/misc/latex.py b/sage/misc/latex.py
    a b def latex_extra_preamble(): 
    605605        sage: from sage.misc.latex import latex_extra_preamble
    606606        sage: print latex_extra_preamble()
    607607        ...
     608        \usepackage{tikz}
     609        <BLANKLINE>
    608610        \newcommand{\ZZ}{\Bold{Z}}
    609611        \newcommand{\NN}{\Bold{N}}
    610612        \newcommand{\RR}{\Bold{R}}