use the faster binomial in combinat

Author: fchapoton

src/sage/combinat/affine_permutation.py

@@ -13,7 +13,6 @@
 # ****************************************************************************
 from itertools import repeat
 
-from sage.arith.misc import binomial
 from sage.categories.affine_weyl_groups import AffineWeylGroups
 from sage.combinat.composition import Composition
 from sage.combinat.partition import Partition
@@ -77,13 +76,13 @@ def __init__(self, parent, lst, check=True):
         """
         if check:
             lst = [ZZ(val) for val in lst]
-        self.k = parent.k
+        self.k = ZZ(parent.k)
         self.n = self.k + 1
-        #This N doesn't matter for type A, but comes up in all other types.
+        # This N doesn't matter for type A, but comes up in all other types.
         if parent.cartan_type()[0] == 'A':
             self.N = self.n
         elif parent.cartan_type()[0] in ['B', 'C', 'D']:
-            self.N = 2*self.k + 1
+            self.N = 2 * self.k + 1
         elif parent.cartan_type()[0] == 'G':
             self.N = 6
         else:
@@ -245,7 +244,7 @@ def is_i_grassmannian(self, i=0, side='right') -> bool:
         """
         return self == self.parent().one() or self.descents(side) == [i]
 
-    def index_set(self):
+    def index_set(self) -> tuple:
         r"""
         Index set of the affine permutation group.
 
@@ -255,7 +254,7 @@ def index_set(self):
             sage: A.index_set()
             (0, 1, 2, 3, 4, 5, 6, 7)
         """
-        return tuple(range(self.k+1))
+        return tuple(range(self.k + 1))
 
     def lower_covers(self, side='right'):
         r"""
@@ -440,13 +439,14 @@ def check(self):
         if not self:
             return
         k = self.parent().k
-        #Type A.
+        # Type A
         if len(self) != k + 1:
-            raise ValueError("length of list must be k+1="+str(k+1))
-        if binomial(k+2,2) != sum(self):
-            raise ValueError("window does not sum to " + str(binomial((k+2),2)))
-        l = sorted([i % (k+1) for i in self])
-        if l != list(range(k+1)):
+            raise ValueError(f"length of list must be k+1={k + 1}")
+        sigma = (k + 2).binomial(2)
+        if sigma != sum(self):
+            raise ValueError(f"window does not sum to {sigma}")
+        l = sorted(i % (k + 1) for i in self)
+        if any(i != j for i, j in enumerate(l)):
             raise ValueError("entries must have distinct residues")
 
     def value(self, i, base_window=False):
@@ -2001,9 +2001,9 @@ class AffinePermutationGroupGeneric(UniqueRepresentation, Parent):
     methods for the specific affine permutation groups.
     """
 
-    #----------------------
-    #Type-free methods.
-    #----------------------
+    # ----------------------
+    # Type-free methods.
+    # ----------------------
 
     def __init__(self, cartan_type):
         r"""
@@ -2014,13 +2014,13 @@ def __init__(self, cartan_type):
         """
         Parent.__init__(self, category=AffineWeylGroups())
         ct = CartanType(cartan_type)
-        self.k = ct.n
+        self.k = ZZ(ct.n)
         self.n = ct.rank()
-        #This N doesn't matter for type A, but comes up in all other types.
+        # This N doesn't matter for type A, but comes up in all other types.
         if ct.letter == 'A':
             self.N = self.k + 1
         elif ct.letter == 'B' or ct.letter == 'C' or ct.letter == 'D':
-            self.N = 2*self.k + 1
+            self.N = 2 * self.k + 1
         elif ct.letter == 'G':
             self.N = 6
         self._cartan_type = ct
@@ -2034,14 +2034,14 @@ def _element_constructor_(self, *args, **keywords):
         """
         return self.element_class(self, *args, **keywords)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         TESTS::
 
             sage: AffinePermutationGroup(['A',7,1])
             The group of affine permutations of type ['A', 7, 1]
         """
-        return "The group of affine permutations of type "+str(self.cartan_type())
+        return "The group of affine permutations of type " + str(self.cartan_type())
 
     def _test_enumeration(self, n=4, **options):
         r"""

src/sage/combinat/baxter_permutations.py

@@ -1,13 +1,11 @@
 """
 Baxter permutations
 """
-
-from sage.structure.unique_representation import UniqueRepresentation
-from sage.structure.parent import Parent
-from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
 from sage.combinat.permutation import Permutations
-
 from sage.rings.integer_ring import ZZ
+from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
+from sage.structure.parent import Parent
+from sage.structure.unique_representation import UniqueRepresentation
 
 
 class BaxterPermutations(UniqueRepresentation, Parent):
@@ -228,12 +226,11 @@ def cardinality(self):
             Integer Ring
         """
         if self._n == 0:
-            return 1
-        from sage.arith.misc import binomial
-        return sum((binomial(self._n + 1, k) *
-                    binomial(self._n + 1, k + 1) *
-                    binomial(self._n + 1, k + 2)) //
-                   ((self._n + 1) * binomial(self._n + 1, 2))
+            return ZZ.one()
+        n = self._n + 1
+        return sum((n.binomial(k) *
+                    n.binomial(k + 1) *
+                    n.binomial(k + 2)) // (n * n.binomial(2))
                    for k in range(self._n))
 
 

src/sage/combinat/blob_algebra.py

@@ -17,22 +17,19 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from sage.structure.parent import Parent
-from sage.structure.unique_representation import UniqueRepresentation
-from sage.structure.element import Element, get_coercion_model
-from sage.structure.richcmp import richcmp
-#from sage.misc.inherit_comparison import InheritComparisonClasscallMetaclass
-from sage.misc.cachefunc import cached_method
-from sage.combinat.subset import powerset
-from sage.arith.misc import binomial
-from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
 from sage.categories.algebras import Algebras
+from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
 from sage.combinat.diagram_algebras import (TemperleyLiebDiagrams, diagram_latex,
                                             TL_diagram_ascii_art)
-from sage.combinat.free_module import CombinatorialFreeModule
 from sage.combinat.dyck_word import DyckWords
-
-#@add_metaclass(InheritComparisonClasscallMetaclass)
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.combinat.subset import powerset
+from sage.misc.cachefunc import cached_method
+from sage.rings.integer_ring import ZZ
+from sage.structure.element import Element, get_coercion_model
+from sage.structure.parent import Parent
+from sage.structure.richcmp import richcmp
+from sage.structure.unique_representation import UniqueRepresentation
 
 
 class BlobDiagram(Element):
@@ -167,7 +164,7 @@ def __init__(self, n):
             sage: BD4 = BlobDiagrams(4)
             sage: TestSuite(BD4).run()
         """
-        self._n = n
+        self._n = ZZ(n)
         self._TL_diagrams = TemperleyLiebDiagrams(n)
         Parent.__init__(self, category=FiniteEnumeratedSets())
 
@@ -181,7 +178,7 @@ def _repr_(self):
             sage: BlobDiagrams(4)
             Blob diagrams of order 4
         """
-        return "Blob diagrams of order {}".format(self._n)
+        return f"Blob diagrams of order {self._n}"
 
     def cardinality(self):
         r"""
@@ -194,7 +191,7 @@ def cardinality(self):
             sage: BD4.cardinality()
             70
         """
-        return binomial(2*self._n, self._n)
+        return (2 * self._n).binomial(self._n)
 
     def order(self):
         r"""
@@ -221,7 +218,7 @@ def base_set(self):
             sage: sorted(BD4.base_set())
             [-4, -3, -2, -1, 1, 2, 3, 4]
         """
-        return frozenset(range(1,self._n+1)).union(range(-self._n,0))
+        return frozenset(range(1, self._n + 1)).union(range(-self._n, 0))
 
     def _element_constructor_(self, marked, unmarked=None):
         r"""

src/sage/combinat/cluster_algebra_quiver/cluster_seed.py

@@ -332,7 +332,7 @@ def __init__(self, data, frozen=None, is_principal=False, user_labels=None, user
                 else:
                     labelset = set(user_labels)
                     # Sanitizes our ``user_labels`` to use Integers instead of ints
-                    user_labels = [ZZ(x) if x in ZZ else x for x in user_labels]
+                    user_labels = [Integer(x) if x in ZZ else x for x in user_labels]
                 if labelset != set(self._nlist + self._mlist) and labelset != set(range(self._n + self._m)):
                     raise ValueError('user_labels conflict with both the given'
                                      ' vertex labels and the default labels')
@@ -3593,7 +3593,7 @@ def mutation_class_iter(self, depth=infinity, show_depth=False,
                             else:
                                 orbits = [index for index in range(n) if index > i or sd2._M[index, i] != 0]
 
-                            clusters[cl2] = [sd2, orbits, clusters[key][2]+[i]]
+                            clusters[cl2] = [sd2, orbits, clusters[key][2] + [i]]
                             if return_paths:
                                 yield (sd2, clusters[cl2][2])
                             else:
@@ -3602,10 +3602,10 @@ def mutation_class_iter(self, depth=infinity, show_depth=False,
             if show_depth and gets_bigger:
                 timer2 = time.time()
                 dc = str(depth_counter)
-                dc += ' ' * (5-len(dc))
+                dc += ' ' * (5 - len(dc))
                 nr = str(len(clusters))
-                nr += ' ' * (10-len(nr))
-                print(f"Depth: {dc} found: {nr} Time: {timer2-timer:.2f} s")
+                nr += ' ' * (10 - len(nr))
+                print(f"Depth: {dc} found: {nr} Time: {timer2 - timer:.2f} s")
 
     def mutation_class(self, depth=infinity, show_depth=False, return_paths=False,
                        up_to_equivalence=True, only_sink_source=False):
@@ -4718,7 +4718,7 @@ def _produce_upper_cluster_algebra_element(self, vd, cList):
             for l in range(num_cols):
                 denominator = denominator * (R.gen(l))**vd[i][0][l]
             # Each copy of a vector in vd contributes a factor of the Laurent polynomial calculated from it.
-            final = (numerator/denominator)**vd[i][1]
+            final = (numerator / denominator)**vd[i][1]
             finalP.append(final)
         laurentP = 1
         # The UCA element for the vector a is the product of the elements produced from the vectors in its decomposition.
@@ -4740,10 +4740,8 @@ def _bino(n, k):
         0
     """
     if n >= 0:
-        from sage.arith.misc import binomial
-        return binomial(n, k)
-    else:
-        return 0
+        return Integer(n).binomial(k)
+    return 0
 
 
 def coeff_recurs(p, q, a1, a2, b, c):
@@ -5192,7 +5190,7 @@ def almost_positive_root(self):
             mt = self._mutation_type._repr_()
             # mt is a string of the shape "['A', 15]"
             # where A is a single letter and 15 is an integer
-            Phi = RootSystem([mt[2: 3], ZZ(mt[6: -1])])
+            Phi = RootSystem([mt[2: 3], Integer(mt[6: -1])])
             Phiplus = Phi.root_lattice().simple_roots()
 
             if self.denominator() == 1:

src/sage/combinat/dyck_word.py

@@ -544,13 +544,13 @@ def _repr_lattice(self, type=None, labelling=None, underpath=True) -> str:
             row = "  " * (n - alst[-1] - 1) + final_fall + "\n"
             for i in range(n - 1):
                 c = 0
-                row = row + "  "*(n-i-2-alst[-i-2])
+                row = row + "  " * (n-i-2-alst[-i-2])
                 c += n-i-2-alst[-i-2]
                 if alst[-i-2]+1 != alst[-i-1]:
                     row += " _"
                 c += alst[-i-2] - alst[-i-1]
                 if underpath:
-                    row += "__"*(alst[-i-2]-alst[-i-1])+"|" + labels[-1] + "x "*(n-c-2-i) + " ."*i + "\n"
+                    row += "__" * (alst[-i-2]-alst[-i-1]) + "|" + labels[-1] + "x "*(n-c-2-i) + " ." * i + "\n"
                 else:
                     row += "__"*(alst[-i-2]-alst[-i-1])+"| " + "x "*(n-c-2-i) + " ."*i + labels[-1] + "\n"
                 labels.pop()
@@ -3780,8 +3780,7 @@ def cardinality(self) -> int:
             ....:      for p in range(7))
             True
         """
-        from sage.arith.misc import binomial
-        return (self.k1 - self.k2 + 1) * binomial(self.k1 + self.k2, self.k2) // (self.k1 + 1)
+        return (self.k1 - self.k2 + 1) * (self.k1 + self.k2).binomial(self.k2) // (self.k1 + 1)
 
 ################################################################
 # Complete Dyck words

src/sage/combinat/interval_posets.py

@@ -47,6 +47,7 @@
 from sage.misc.lazy_attribute import lazy_attribute
 from sage.misc.lazy_import import lazy_import
 from sage.rings.integer import Integer
+from sage.rings.integer_ring import ZZ
 from sage.rings.semirings.non_negative_integer_semiring import NN
 from sage.sets.non_negative_integers import NonNegativeIntegers
 from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
@@ -3757,11 +3758,10 @@ def cardinality(self) -> Integer:
             sage: [TamariIntervalPosets(i).cardinality() for i in range(6)]
             [1, 1, 3, 13, 68, 399]
         """
-        from sage.arith.misc import binomial
         n = self._size
         if n == 0:
-            return Integer(1)
-        return (2 * binomial(4 * n + 1, n - 1)) // (n * (n + 1))
+            return ZZ.one()
+        return (2 * Integer(4 * n + 1).binomial(n - 1)) // (n * (n + 1))
         # return Integer(2 * factorial(4*n+1)/(factorial(n+1)*factorial(3*n+2)))
 
     def __iter__(self) -> Iterator[TIP]:

src/sage/combinat/posets/posets.py

@@ -292,7 +292,6 @@
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_attribute import lazy_attribute
 from sage.misc.misc_c import prod
-from sage.arith.misc import binomial
 from sage.categories.category import Category
 from sage.categories.sets_cat import Sets
 from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
@@ -1815,7 +1814,7 @@ def atkinson(self, a):
         for r in range(1, n + 1):
             new_a_spec.append(0)
             for i in range(max(1, r - n + k), min(r, k) + 1):
-                k_val = binomial(r - 1, i - 1) * binomial(n - r, k - i)
+                k_val = Integer(r - 1).binomial(i - 1) * Integer(n - r).binomial(k - i)
                 new_a_spec[-1] += k_val * a_spec[i - 1] * n_lin_exts
         return new_a_spec
 
@@ -5295,7 +5294,7 @@ def factor(self):
         dg = self._hasse_diagram
         if not dg.is_connected():
             raise NotImplementedError('the poset is not connected')
-        if ZZ(dg.num_verts()).is_prime():
+        if Integer(dg.num_verts()).is_prime():
             return [self]
         G = dg.to_undirected()
         is_product, dic = G.is_cartesian_product(relabeling=True)
@@ -6492,7 +6491,7 @@ def random_order_ideal(self, direction='down'):
                 with seed(currseed):
                     for _ in range(count):
                         for element in range(n):
-                            if random() % 2 == 1:
+                            if random() % 2:  # should use one random bit
                                 s = [state[i] for i in lower_covers[element]]
                                 if 1 not in s:
                                     if 2 not in s:
@@ -8141,7 +8140,7 @@ def is_eulerian(self, k=None, certificate=False):
         n = self.cardinality()
         if n == 1:
             return True
-        if k is None and not certificate and n % 2 == 1:
+        if k is None and not certificate and n % 2:
             return False
 
         H = self._hasse_diagram