passagemath-combinat 10.6.1__cp312-cp312-musllinux_1_2_aarch64.whl → 10.8.1a1__cp312-cp312-musllinux_1_2_aarch64.whl

sage/algebras/q_commuting_polynomials.py

@@ -290,7 +290,7 @@ class qCommutingPolynomials(qCommutingPolynomials_generic):
         indices = FreeAbelianMonoid(len(names), names)
         qCommutingPolynomials_generic.__init__(self, q, B, indices, indices.variable_names())
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -308,7 +308,7 @@ class qCommutingPolynomials(qCommutingPolynomials_generic):
         names = ", ".join(self.variable_names())
         return "{}-commuting polynomial ring in {} over {} with matrix:\n{}".format(self._q, names, self.base_ring(), self._B)
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -467,7 +467,7 @@ class qCommutingLaurentPolynomials(qCommutingPolynomials_generic):
         self._display_group = FreeGroup(names=names, abelian=True, bracket=False)
         qCommutingPolynomials_generic.__init__(self, q, B, indices, names)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -485,7 +485,7 @@ class qCommutingLaurentPolynomials(qCommutingPolynomials_generic):
         names = ", ".join(self.variable_names())
         return "{}-commuting Laurent polynomial ring in {} over {} with matrix:\n{}".format(self._q, names, self.base_ring(), self._B)
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -500,7 +500,7 @@ class qCommutingLaurentPolynomials(qCommutingPolynomials_generic):
         names = ", ".join(r"{}^{{\pm}}".format(v) for v in self.variable_names())
         return "{}[{}]_{{{}}}".format(latex(self.base_ring()), names, self._q)
 
-    def _repr_term(self, m):
+    def _repr_term(self, m) -> str:
         r"""
         Return a latex representation of the basis element indexed by ``m``.
 
@@ -520,7 +520,7 @@ class qCommutingLaurentPolynomials(qCommutingPolynomials_generic):
         G = self._display_group
         return repr(G.prod(g ** val for g, val in zip(G.gens(), m) if val != 0))
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a latex representation of the basis element indexed by ``m``.
 

sage/algebras/q_system.py

@@ -181,7 +181,7 @@ class QSystem(CombinatorialFreeModule):
         CombinatorialFreeModule.__init__(self, base_ring, basis,
                                          prefix='Q', category=category)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -201,7 +201,7 @@ class QSystem(CombinatorialFreeModule):
             res += "Twisted "
         return "{}Q-system of type {} over {}".format(res, self._cartan_type, self.base_ring())
 
-    def _repr_term(self, t):
+    def _repr_term(self, t) -> str:
         """
         Return a string representation of the basis element indexed by ``t``.
 
@@ -222,7 +222,7 @@ class QSystem(CombinatorialFreeModule):
             return ret
         return '*'.join(repr_gen(x) for x in t._sorted_items())
 
-    def _latex_term(self, t):
+    def _latex_term(self, t) -> str:
         r"""
         Return a `\LaTeX` representation of the basis element indexed
         by ``t``.

sage/algebras/quantum_clifford.py

@@ -8,7 +8,7 @@ AUTHORS:
 - Travis Scrimshaw (2021-05): initial version
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #  Copyright (C) 2021 Travis Scrimshaw <tcscrims at gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify
@@ -16,7 +16,7 @@ AUTHORS:
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
-#*****************************************************************************
+# ***************************************************************************
 
 from sage.misc.cachefunc import cached_method
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
@@ -191,7 +191,7 @@ class QuantumCliffordAlgebra(CombinatorialFreeModule):
         CombinatorialFreeModule.__init__(self, F, indices, category=cat)
         self._assign_names(self.algebra_generators().keys())
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -204,7 +204,7 @@ class QuantumCliffordAlgebra(CombinatorialFreeModule):
         return "Quantum Clifford algebra of rank {} and twist {} with q={} over {}".format(
             self._n, self._k, self._q, self.base_ring())
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -381,7 +381,7 @@ class QuantumCliffordAlgebraGeneric(QuantumCliffordAlgebra):
                    for w in product(*[list(range((4-2*abs(p[i]))*k)) for i in range(n)])]
         super().__init__(n, k, q, F, psi, indices)
 
-    def _repr_term(self, m):
+    def _repr_term(self, m) -> str:
         r"""
         Return a string representation of the basis element indexed by ``m``.
 
@@ -413,7 +413,7 @@ class QuantumCliffordAlgebraGeneric(QuantumCliffordAlgebra):
             return rv
         return '1'
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a latex representation for the basis element indexed by ``m``.
 
@@ -681,7 +681,7 @@ class QuantumCliffordAlgebraRootUnity(QuantumCliffordAlgebra):
                    for w in product(list(range(2*k)), repeat=n)]
         super().__init__(n, k, q, F, psi, indices)
 
-    def _repr_term(self, m):
+    def _repr_term(self, m) -> str:
         r"""
         Return a string representation of the basis element indexed by ``m``.
 
@@ -722,7 +722,7 @@ class QuantumCliffordAlgebraRootUnity(QuantumCliffordAlgebra):
             return rv
         return '1'
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a latex representation for the basis element indexed by ``m``.
 

sage/algebras/quantum_groups/fock_space.py

@@ -1326,6 +1326,20 @@ class FockSpace(Parent, UniqueRepresentation):
                 |3> + q*|2, 1>
                 sage: G._G_to_fock_basis(Partition([2,1]))
                 |2, 1> + q*|1, 1, 1>
+
+            TESTS:
+
+            Check that :issue:`41408` is fixed::
+
+                sage: Fock = FockSpace(3, [0, 1])
+                sage: G = Fock.G()
+                sage: la = PartitionTuple([[6], [5,5,1]])
+                sage: v = G._G_to_fock_basis(la)
+                sage: len(v.support())
+                261
+                sage: v
+                |[6], [5, 5, 1]> + q*|[6], [5, 4, 1, 1]> + q*|[6], [5, 3, 3]>
+                 + ... + q^7*|[], [3, 3, 3, 2, 1, 1, 1, 1, 1, 1]>
             """
             # Special case for the empty partition
             if la.size() == 0:
@@ -1355,13 +1369,40 @@ class FockSpace(Parent, UniqueRepresentation):
                 return fock.sum_of_terms((fock._indices([[]]*k + list(pt)), c) for pt,c in cur)
 
             cur = R.A()._A_to_fock_basis(la)
-            s = sorted(cur.support())  # Sort lex, which respects dominance order
-            s.pop()  # Remove the largest
+
+            def domorder_insertion(data, elt):
+                """
+                Add ``elt`` at the largest position of ``data`` such that
+                it dominants all larger entries.
+                """
+                for i in range(len(data)-1, -1, -1):
+                    if not data[i].dominates(elt):
+                        data.insert(i+1, elt)
+                        return
+                data.insert(0, elt)
+
+            # Build the elimination list s so that whenever y.dominates(x),
+            # y appears after x.
+            if len(R._multicharge) == 1:
+                s = [x for x in cur.support() if x in self._indices]
+                s.sort()  # Sort lex, which respects dominance order
+                s.pop()  # Remove the largest
+            else:
+                # In level > 1, the default comparison on PartitionTuples is lexicographic
+                # and does not necessarily refine dominance order.
+                s = []
+                for x in cur.support():
+                    if x == la or x not in self._indices:
+                        continue
+                    domorder_insertion(s, x)
 
             q = R._q
+
             while s:
                 mu = s.pop()
+                # assert mu in self._indices
                 d = cur[mu].denominator()
+
                 k = d.degree()
                 n = cur[mu].numerator()
                 if k != 0 or n.constant_coefficient() != 0:
@@ -1370,14 +1411,13 @@ class FockSpace(Parent, UniqueRepresentation):
                     gamma += n[k]
                     cur -= gamma * self._G_to_fock_basis(mu)
 
-                    # Add any new support elements
                     for x in cur.support():
-                        if x == mu or not mu.dominates(x): # Add only things (strictly) dominated by mu
+                        # Add only new support elements that are (strictly) dominanted by mu
+                        # and correspond to crystal basis elements.
+                        if x == mu or x in s or not mu.dominates(x) or x not in self._indices:
                             continue
-                        for i in reversed(range(len(s))):
-                            if not s[i].dominates(x):
-                                s.insert(i+1, x)
-                                break
+                        domorder_insertion(s, x)
+
             return cur
 
     lower_global_crystal = G

sage/algebras/quantum_groups/quantum_group_gap.py

@@ -199,7 +199,7 @@ class QuaGroupModuleElement(Element):
         """
         return self._libgap
 
-    _libgap_ = _gap_ = gap
+    _libgap_ = gap
 
     def _add_(self, other):
         r"""
@@ -433,7 +433,7 @@ class QuantumGroup(UniqueRepresentation, Parent):
         """
         return self._libgap
 
-    _libgap_ = _gap_ = gap
+    _libgap_ = gap
 
     def cartan_type(self):
         """
@@ -1603,7 +1603,7 @@ class QuantumGroupModule(Parent, UniqueRepresentation):
         """
         return self._libgap
 
-    _libgap_ = _gap_ = gap
+    _libgap_ = gap
 
     def _element_constructor_(self, elt):
         """
@@ -2355,8 +2355,7 @@ class LowerHalfQuantumGroup(Parent, UniqueRepresentation):
             sage: Q = QuantumGroup(['A',2])
             sage: B = Q.lower_half()
             sage: basis = B.basis(); basis
-            Lazy family (monomial(i))_{i in The Cartesian product of
-             (Non negative integers, Non negative integers, Non negative integers)}
+            Lazy family (monomial(i))_{i in The Cartesian product of 3 copies of Non negative integers}
             sage: basis[1,2,1]
             F[a1]*F[a1+a2]^(2)*F[a2]
             sage: basis[1,2,4]
@@ -2391,8 +2390,7 @@ class LowerHalfQuantumGroup(Parent, UniqueRepresentation):
             sage: Q = QuantumGroup(['A',2])
             sage: B = Q.lower_half()
             sage: C = B.canonical_basis_elements(); C
-            Lazy family (Canonical basis(i))_{i in The Cartesian product of
-             (Non negative integers, Non negative integers)}
+            Lazy family (Canonical basis(i))_{i in The Cartesian product of 2 copies of Non negative integers}
             sage: C[2,1]
             [F[a1]^(2)*F[a2], F[a1]*F[a1+a2] + (q^2)*F[a1]^(2)*F[a2]]
             sage: C[1,2]

sage/algebras/quantum_matrix_coordinate_algebra.py

@@ -84,7 +84,7 @@ class QuantumMatrixCoordinateAlgebra_abstract(CombinatorialFreeModule):
             indices = IndexedFreeAbelianMonoid(gp_indices, sorting_key=indices_key)
         CombinatorialFreeModule.__init__(self, R, indices, category=category)
 
-    def _repr_term(self, m):
+    def _repr_term(self, m) -> str:
         r"""
         Return a string representation of the term indexed by ``m``.
 
@@ -110,7 +110,7 @@ class QuantumMatrixCoordinateAlgebra_abstract(CombinatorialFreeModule):
         return '*'.join(('x[{},{}]'.format(*k) if k != 'c' else 'c') + exp(e)
                         for k, e in m._sorted_items())
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a latex representation of the term indexed by ``m``.
 
@@ -283,7 +283,7 @@ class QuantumMatrixCoordinateAlgebra_abstract(CombinatorialFreeModule):
                 if ax[0] < bx[0]:
                     # In order, so nothing more to do
                     break
-                elif ax[0] == bx[0]:
+                if ax[0] == bx[0]:
                     if ax[1] > bx[1]:
                         # x_{it} x_{ij} = q^{-1} x_{ij} x_{it} if t < j
                         coeff *= qi ** (ae * be)
@@ -542,7 +542,7 @@ class QuantumMatrixCoordinateAlgebra(QuantumMatrixCoordinateAlgebra_abstract):
         names = [base.format(*k) for k in gp_indices]
         self._assign_names(names)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -559,7 +559,7 @@ class QuantumMatrixCoordinateAlgebra(QuantumMatrixCoordinateAlgebra_abstract):
         txt = "Quantized coordinate algebra of M({}, {}) with q={} over {}"
         return txt.format(self._m, self._n, self._q, self.base_ring())
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -764,7 +764,7 @@ class QuantumGL(QuantumMatrixCoordinateAlgebra_abstract):
         names.append('c')
         self._assign_names(names)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -777,7 +777,7 @@ class QuantumGL(QuantumMatrixCoordinateAlgebra_abstract):
         txt = "Quantized coordinate algebra of GL({}) with q={} over {}"
         return txt.format(self._n, self._q, self.base_ring())
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 

sage/algebras/quantum_oscillator.py

@@ -175,7 +175,7 @@ class QuantumOscillatorAlgebra(CombinatorialFreeModule):
         return "Quantum oscillator algebra with q={} over {}".format(
             self._q, self.base_ring())
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -327,7 +327,7 @@ class QuantumOscillatorAlgebra(CombinatorialFreeModule):
             return kstr
         return '1'
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a latex representation for the basis element indexed by ``m``.
 
@@ -533,7 +533,7 @@ class FockSpaceRepresentation(CombinatorialFreeModule):
         """
         return "Fock space representation of {}".format(self._O)
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 

sage/algebras/quaternion_algebra_element.py

@@ -5,9 +5,11 @@
 # Backward compatible unpickle functions
 #######################################################################
 
-from .quatalg.quaternion_algebra_element import (QuaternionAlgebraElement_generic,
-                                                QuaternionAlgebraElement_rational_field,
-                                                QuaternionAlgebraElement_number_field)
+from sage.algebras.quatalg.quaternion_algebra_element import (
+    QuaternionAlgebraElement_generic,
+    QuaternionAlgebraElement_number_field,
+    QuaternionAlgebraElement_rational_field,
+)
 
 
 def unpickle_QuaternionAlgebraElement_generic_v0(*args):

sage/algebras/schur_algebra.py

@@ -245,7 +245,7 @@ class SchurAlgebra(CombinatorialFreeModule):
                                          prefix='S', bracket=False,
                                          category=AlgebrasWithBasis(R).FiniteDimensional())
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return the string representation of ``self``.
 
@@ -432,7 +432,7 @@ class SchurTensorModule(CombinatorialFreeModule_Tensor):
         g = self._schur.module_morphism(self._monomial_product, codomain=self)
         self._schur_action = self.module_morphism(g, codomain=self, position=1)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return the string representation of ``self``.
 
@@ -457,7 +457,7 @@ class SchurTensorModule(CombinatorialFreeModule_Tensor):
             sage: T = SchurTensorModule(QQ, 2, 3)
             sage: T.construction()
         """
-        return None
+        return
 
     def _monomial_product(self, xi, v):
         """

sage/algebras/shuffle_algebra.py

@@ -187,7 +187,7 @@ class ShuffleAlgebra(CombinatorialFreeModule):
         """
         return self._alphabet
 
-    def _repr_term(self, t):
+    def _repr_term(self, t) -> str:
         """
         Return a string representation of the basis element indexed by ``t``.
 
@@ -199,7 +199,7 @@ class ShuffleAlgebra(CombinatorialFreeModule):
         """
         return "{!s}[{!s}]".format(self._print_options['prefix'], repr(t)[6:])
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Text representation of this shuffle algebra.
 
@@ -540,10 +540,7 @@ class ShuffleAlgebra(CombinatorialFreeModule):
         # shuffle algebras in the same variable over any base that coerces in:
         if isinstance(R, ShuffleAlgebra):
             if R.variable_names() == self.variable_names():
-                if self.base_ring().has_coerce_map_from(R.base_ring()):
-                    return True
-                else:
-                    return False
+                return self.base_ring().has_coerce_map_from(R.base_ring())
 
         if isinstance(R, DualPBWBasis):
             return self.has_coerce_map_from(R._alg)
@@ -691,7 +688,7 @@ class DualPBWBasis(CombinatorialFreeModule):
         CombinatorialFreeModule.__init__(self, R, Words(names), prefix='S',
                                          category=cat)
 
-    def _repr_term(self, t):
+    def _repr_term(self, t) -> str:
         """
         Return a string representation of the basis element indexed by ``t``.
 
@@ -703,7 +700,7 @@ class DualPBWBasis(CombinatorialFreeModule):
         """
         return "{!s}[{!s}]".format(self._print_options['prefix'], repr(t)[6:])
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.