Trac #32962: some details in Dyck words

mostly micro-optimisations

URL: https://trac.sagemath.org/32962
Reported by: chapoton
Ticket author(s): Frédéric Chapoton
Reviewer(s): Samuel Lelièvre

Author: Release Manager

src/sage/combinat/dyck_word.py

@@ -78,6 +78,7 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 from __future__ import annotations
+from typing import Iterator
 
 from .combinat import CombinatorialElement, catalan_number
 from sage.combinat.combinatorial_map import combinatorial_map
@@ -141,10 +142,9 @@ def replace_parens(x):
     """
     if x == '(':
         return open_symbol
-    elif x == ')':
+    if x == ')':
         return close_symbol
-    else:
-        raise ValueError
+    raise ValueError
 
 
 def replace_symbols(x):
@@ -185,10 +185,9 @@ def replace_symbols(x):
     """
     if x == open_symbol:
         return '('
-    elif x == close_symbol:
+    if x == close_symbol:
         return ')'
-    else:
-        raise ValueError
+    raise ValueError
 
 
 class DyckWord(CombinatorialElement):
@@ -605,7 +604,7 @@ def __str__(self) -> str:
             sage: print(DyckWord([1, 1, 0, 0]))
             (())
         """
-        return "".join(map(replace_symbols, [x for x in self]))
+        return "".join(replace_symbols(x) for x in self)
 
     def to_path_string(self, unicode=False) -> str:
         r"""
@@ -1756,7 +1755,27 @@ def tamari_interval(self, other):
         from sage.combinat.interval_posets import TamariIntervalPosets
         return TamariIntervalPosets.from_dyck_words(self, other)
 
-    def to_area_sequence(self) -> list:
+    def _area_sequence_iter(self) -> Iterator[int]:
+        """
+        Return an iterator producing the area sequence.
+
+        .. SEEALSO:: :meth:`to_area_sequence`
+
+        EXAMPLES::
+
+            sage: d = DyckWord([1, 0, 1, 0])
+            sage: [a for a in d._area_sequence_iter()]
+            [0, 0]
+        """
+        a = 0
+        for move in self:
+            if move == open_symbol:
+                yield a
+                a += 1
+            else:
+                a -= 1
+
+    def to_area_sequence(self) -> list[int]:
         r"""
         Return the area sequence of the Dyck word ``self``.
 
@@ -1806,15 +1825,7 @@ def to_area_sequence(self) -> list:
             sage: DyckWord([1,1,0,1,0,0,1,1,0,1,0,1,0,0]).to_area_sequence()
             [0, 1, 1, 0, 1, 1, 1]
         """
-        seq = []
-        a = 0
-        for move in self:
-            if move == open_symbol:
-                seq.append(a)
-                a += 1
-            else:
-                a -= 1
-        return seq
+        return list(self._area_sequence_iter())
 
 
 class DyckWord_complete(DyckWord):
@@ -1927,8 +1938,8 @@ def list_parking_functions(self):
             sage: DyckWord([1,0,1,0,1,0]).list_parking_functions()
             Standard permutations of 3
         """
-        alist = self.to_area_sequence()
-        return Permutations([i - alist[i] + 1 for i in range(len(alist))])
+        alist = self._area_sequence_iter()
+        return Permutations([i - ai + 1 for i, ai in enumerate(alist)])
         # TODO: upon implementation of ParkingFunction class
         # map(ParkingFunction, Permutations([i - alist[i]+1 for i in range(len(alist))]))
 
@@ -1956,9 +1967,9 @@ def reading_permutation(self) -> Permutation:
             sage: DyckWord([1,0,1,1,0,0,1,0]).reading_permutation()
             [3, 4, 2, 1]
         """
-        alist = self.to_area_sequence()
-        if not alist:
+        if not self:
             return Permutation([])  # type: ignore
+        alist = self.to_area_sequence()
         m = max(alist)
         p1 = Word([m - alist[-i - 1]
                    for i in range(len(alist))]).standard_permutation()
@@ -2075,10 +2086,10 @@ def to_312_avoiding_permutation(self) -> Permutation:
             True
         """
         n = self.semilength()
-        area = self.to_area_sequence()
+        area = self._area_sequence_iter()
         pi = Permutations(n).one()
-        for j in range(n):
-            for i in range(area[j]):
+        for j, aj in enumerate(area):
+            for i in range(aj):
                 pi = pi.apply_simple_reflection(j - i)
         return pi
 
@@ -2793,9 +2804,9 @@ def area_dinv_to_bounce_area_map(self) -> DyckWord:
             sage: DyckWord([1,0,1,0]).area_dinv_to_bounce_area_map()
             [1, 1, 0, 0]
         """
-        a = self.to_area_sequence()
-        if not a:
+        if not self:
             return self
+        a = self.to_area_sequence()
         a.reverse()
         image = []
         for i in range(max(a), -2, -1):
@@ -2844,13 +2855,13 @@ def bounce_area_to_area_dinv_map(self) -> DyckWord:
             sage: DyckWord([1,0,1,0]).bounce_area_to_area_dinv_map()
             [1, 1, 0, 0]
         """
-        aseq = self.to_area_sequence()
+        aseq = self._area_sequence_iter()
         out: list[int] = []
         zeros: list[int] = []
-        for i in range(len(aseq)):
-            p = (zeros + [len(out)])[aseq[i]]
+        for ai in aseq:
+            p = (zeros + [len(out)])[ai]
             out = [1] + out[p:] + [0] + out[:p]
-            zeros = [0] + [j + len(out) - p for j in zeros[:aseq[i]]]
+            zeros = [0] + [j + len(out) - p for j in zeros[:ai]]
         return DyckWord(out)  # type:ignore
 
     def area(self) -> int:
@@ -3093,9 +3104,11 @@ def dinv(self, labeling=None) -> int:
         """
         alist = self.to_area_sequence()
         cnt = 0
-        for j in range(len(alist)):
+        for j, aj in enumerate(alist):
+            if labeling is not None:
+                lj = labeling[j]
             for i in range(j):
-                if (alist[i] - alist[j] == 0 and (labeling is None or labeling[i] < labeling[j])) or (alist[i] - alist[j] == 1 and (labeling is None or labeling[i] > labeling[j])):
+                if (alist[i] == aj and (labeling is None or labeling[i] < lj)) or (alist[i] - aj == 1 and (labeling is None or labeling[i] > lj)):
                     cnt += 1
         return cnt
 
@@ -3933,10 +3946,12 @@ def __iter__(self):
 
     class height_poset(UniqueRepresentation, Parent):
         r"""
-        The poset of complete Dyck words compared componentwise by
-        ``heights``.
+        The poset of complete Dyck words compared componentwise by ``heights``.
+
         This is, ``D`` is smaller than or equal to ``D'`` if it is
         weakly below ``D'``.
+
+        This is implemented by comparison of area sequences.
         """
         def __init__(self):
             r"""
@@ -3974,7 +3989,7 @@ def le(self, dw1, dw2):
 
             .. SEEALSO::
 
-                :meth:`heights<sage.combinat.dyck_word.DyckWord.heights>`
+                :meth:`~sage.combinat.dyck_word.DyckWord.to_area_sequence`
 
             EXAMPLES::
 
@@ -3994,10 +4009,10 @@ def le(self, dw1, dw2):
                 True, False, False, False, False, True]
             """
             if len(dw1) != len(dw2):
-                raise ValueError("Length mismatch: %s and %s" % (dw1, dw2))
-            sh = dw1.heights()
-            oh = dw2.heights()
-            return all(sh[i] <= oh[i] for i in range(len(dw1)))
+                raise ValueError(f"length mismatch: {dw1} and {dw2}")
+            ar1 = dw1._area_sequence_iter()
+            ar2 = dw2._area_sequence_iter()
+            return all(a1 <= a2 for a1, a2 in zip(ar1, ar2))
 
 
 class CompleteDyckWords_size(CompleteDyckWords, DyckWords_size):