more uses of cython code for is_fully_comm

Author: fchapoton

src/sage/combinat/affine_permutation.py

@@ -217,7 +217,7 @@ def __call__(self, i):
         """
         return self.value(i)
 
-    def is_i_grassmannian(self, i=0, side="right"):
+    def is_i_grassmannian(self, i=0, side="right") -> bool:
         r"""
         Test whether ``self`` is `i`-grassmannian, i.e., either is the
         identity or has ``i`` as the sole descent.
@@ -277,7 +277,7 @@ def lower_covers(self,side="right"):
         S = self.descents(side)
         return [self.apply_simple_reflection(i, side) for i in S]
 
-    def is_one(self):
+    def is_one(self) -> bool:
         r"""
         Tests whether the affine permutation is the identity.
 
@@ -876,18 +876,21 @@ def to_lehmer_code(self, typ='decreasing', side='right'):
                         code[i] += (b-i) // (self.k+1) + 1
         return Composition(code)
 
-    def is_fully_commutative(self):
+    def is_fully_commutative(self) -> bool:
         r"""
-        Determine whether ``self`` is fully commutative, i.e., has no
-        reduced words with a braid.
+        Determine whether ``self`` is fully commutative.
+
+        This means that it has no reduced word with a braid.
+
+        This uses a specific algorithm.
 
         EXAMPLES::
 
             sage: A = AffinePermutationGroup(['A',7,1])
-            sage: p=A([3, -1, 0, 6, 5, 4, 10, 9])
+            sage: p = A([3, -1, 0, 6, 5, 4, 10, 9])
             sage: p.is_fully_commutative()
             False
-            sage: q=A([-3, -2, 0, 7, 9, 2, 11, 12])
+            sage: q = A([-3, -2, 0, 7, 9, 2, 11, 12])
             sage: q.is_fully_commutative()
             True
         """
@@ -900,14 +903,12 @@ def is_fully_commutative(self):
             if c[i] > 0:
                 if firstnonzero is None:
                     firstnonzero = i
-                if m != -1 and c[i] - (i-m) >= c[m]:
+                if m != -1 and c[i] - (i - m) >= c[m]:
                     return False
                 m = i
-        #now check m (the last non-zero) against firstnonzero.
-        d = self.n-(m-firstnonzero)
-        if c[firstnonzero]-d >= c[m]:
-            return False
-        return True
+        # now check m (the last non-zero) against first non-zero.
+        d = self.n - (m - firstnonzero)
+        return not c[firstnonzero] - d >= c[m]
 
     def to_bounded_partition(self, typ='decreasing', side='right'):
         r"""

src/sage/combinat/fully_commutative_elements.py

@@ -153,44 +153,23 @@ def is_fully_commutative(self):
             sage: x = FC.element_class(FC, [1, 2, 1], check=False); x.is_fully_commutative()
             False
         """
-        matrix = self.parent().coxeter_group().coxeter_matrix()
-        w = tuple(self)
-
-        # The following function detects 'braid' words.
-        def contains_long_braid(w):
-            for i in range(len(w) - 2):
-                a = w[i]
-                b = w[i + 1]
-                m = matrix[a, b]
-                if m > 2 and i + m <= len(w):
-                    ab_braid = (a, b) * (m // 2) + ((a,) if m % 2 else ())
-                    if w[i:i + m] == ab_braid:
-                        return True
-            return False
+        word = list(self)
+        from sage.combinat.root_system.braid_orbit import is_fully_commutative as is_fully_comm
 
-        # The following function applies a commutation relation on a word.
-        def commute_once(word, i):
-            return word[:i] + (word[i + 1], word[i]) + word[i + 2:]
+        group = self.parent().coxeter_group()
+        braid_rels = group.braid_relations()
+        I = group.index_set()
 
-        # A word is the reduced word of an FC element iff no sequence of
-        # commutation relations on it yields a word with a 'braid' word:
-        if contains_long_braid(w):
-            return False
-        else:
-            l, checked, queue = len(w), {w}, deque([w])
-            while queue:
-                word = queue.pop()
-                for i in range(l - 1):
-                    a, b = word[i], word[i + 1]
-                    if matrix[a, b] == 2:
-                        new_word = commute_once(word, i)
-                        if new_word not in checked:
-                            if contains_long_braid(new_word):
-                                return False
-                            else:
-                                checked.add(new_word)
-                                queue.appendleft(new_word)
-            return True
+        from sage.rings.integer_ring import ZZ
+        be_careful = any(i not in ZZ for i in I)
+
+        if be_careful:
+            Iinv = {i: j for j, i in enumerate(I)}
+            word = [Iinv[i] for i in word]
+            braid_rels = [[[Iinv[i] for i in l],
+                           [Iinv[i] for i in r]] for l, r in braid_rels]
+
+        return is_fully_comm(word, braid_rels)
 
     # Representing FC elements: Heaps
     def heap(self, **kargs):