schubmult 2.0.3__py3-none-any.whl → 2.0.4__py3-none-any.whl

schubmult/sage_integration/_fast_double_schubert_polynomial_ring.py

@@ -1,18 +1,23 @@
+from functools import cache
+
+import symengine as syme
 from sage.all import *  # noqa: F403
-from sage.categories.graded_bialgebras_with_basis import GradedBialgebrasWithBasis
+from sage.categories.cartesian_product import cartesian_product
 from sage.categories.graded_algebras_with_basis import GradedAlgebrasWithBasis
+from sage.categories.graded_bialgebras_with_basis import GradedBialgebrasWithBasis
+from sage.combinat.composition import (
+    Composition,
+    Compositions,
+)
 from sage.combinat.free_module import CombinatorialFreeModule
-from sage.categories.cartesian_product import cartesian_product
-from sage.combinat.permutation import Permutations, Permutation, from_lehmer_code
+from sage.combinat.permutation import Permutation, Permutations, from_lehmer_code
 from sage.misc.cachefunc import cached_method
+from sage.misc.parser import Parser
+from sage.rings.polynomial.flatten import FlatteningMorphism
 from sage.rings.polynomial.multi_polynomial import MPolynomial
 from sage.rings.polynomial.multi_polynomial_ring import MPolynomialRing_base
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
-from sage.rings.polynomial.flatten import FlatteningMorphism
-from sage.combinat.composition import (
-    Compositions,
-    Composition,
-)
+from sympy import sympify
 
 # from . import (
 #     FastSchubertPolynomialRing_base,
@@ -20,16 +25,11 @@ from sage.combinat.composition import (
 #     FastSchubertPolynomial,
 # )
 import schubmult.sage_integration._fast_schubert_polynomial_ring as bork
-from ._indexing import _coerce_index
-
-from functools import cache
-import schubmult.schubmult_q_double as qyz
 import schubmult.schubmult_double as yz
-from sympy import sympify
-import symengine as syme
+import schubmult.schubmult_q_double as qyz
 from schubmult.perm_lib import permtrim
 
-from sage.misc.parser import Parser
+from ._indexing import _coerce_index
 
 
 def FastDoubleSchubertPolynomialRing(
@@ -38,12 +38,13 @@ def FastDoubleSchubertPolynomialRing(
     base_variable_name: str,
     coeff_variable_names: str | tuple[str],
     *,
-    indices: tuple[int] = tuple([1]),
+    indices: tuple[int] = (1,),
     code_display: bool = False,
     q_varname: str = "q",
     is_quantum: bool = False,
 ):
-    """Wrapper function to return a double Schubert polynomial Ring
+    """
+    Wrapper function to return a double Schubert polynomial Ring
 
         Calls the _xbasis class to return a double or quantum double Schubert
         polynomial ring with the indicated base ring, number of variables,
@@ -58,7 +59,7 @@ def FastDoubleSchubertPolynomialRing(
     X([2, 4, 3, 1]) + X([2, 1, 4, 3], "z")
     ```
 
-        Args:
+    Args:
             R (sage ring): The base ring
             num_vars (int): Cardinality of the sets of variables
             base_variable_name (str): Base variable name
@@ -68,8 +69,9 @@ def FastDoubleSchubertPolynomialRing(
             q_varname (str, optional): Variable name of the q-ring. Defaults to "q".
             is_quantum (bool, optional): Whether or not the ring is quantum. Defaults to False.
 
-        Returns:
+    Returns:
             FastDoubleSchubertPolynomialRing_xbasis: Basis element generator of the ring
+
     """
     QR = None
     if is_quantum:
@@ -96,7 +98,8 @@ def FastQuantumDoubleSchubertPolynomialRing(
     code_display=False,
     q_varname="q",
 ):
-    """Quantum double Schubert ring generator
+    """
+    Quantum double Schubert ring generator
 
     Wraps FastDoubleSchubertPolynomialRing(), omitting indices and setting
     is_quantum to True.
@@ -111,6 +114,7 @@ def FastQuantumDoubleSchubertPolynomialRing(
 
     Returns:
         FastDoubleSchubertPolynomialRing_xbasis: Basis element generator of the quantum ring
+
     """
     return FastDoubleSchubertPolynomialRing(
         R,
@@ -118,7 +122,7 @@ def FastQuantumDoubleSchubertPolynomialRing(
         base_variable_name,
         coeff_variable_names,
         code_display=code_display,
-        indices=tuple([1]),
+        indices=(1,),
         is_quantum=True,
         q_varname=q_varname,
     )
@@ -133,8 +137,7 @@ class FastDoubleSchubertPolynomial_class(CombinatorialFreeModule.Element):
     def q_varname(self):
         if not self.parent().is_quantum:
             return None
-        else:
-            return self.parent()._q_varname
+        return self.parent()._q_varname
 
     @property
     def base_polynomial_ring(self):
@@ -148,8 +151,7 @@ class FastDoubleSchubertPolynomial_class(CombinatorialFreeModule.Element):
     def q_ring(self):
         if not self.parent()._quantum:
             return None
-        else:
-            return self.parent()._q_ring
+        return self.parent()._q_ring
 
     def expand(self):
         if self.parent()._quantum:
@@ -163,20 +165,19 @@ class FastDoubleSchubertPolynomial_class(CombinatorialFreeModule.Element):
                         v,
                     )
                     for k, v in self.monomial_coefficients().items()
-                ]
-            )
-        else:
-            return sum(
-                [
-                    yz.schubmult(
-                        {(1, 2): v},
-                        tuple(_coerce_index(k[0], self.parent()._ascode, False)),
-                        self.parent()._base_polynomial_ring.gens(),
-                        self.parent()._coeff_polynomial_rings[k[1]].gens(),
-                    ).get((1, 2), 0)
-                    for k, v in self.monomial_coefficients().items()
-                ]
+                ],
             )
+        return sum(
+            [
+                yz.schubmult(
+                    {(1, 2): v},
+                    tuple(_coerce_index(k[0], self.parent()._ascode, False)),
+                    self.parent()._base_polynomial_ring.gens(),
+                    self.parent()._coeff_polynomial_rings[k[1]].gens(),
+                ).get((1, 2), 0)
+                for k, v in self.monomial_coefficients().items()
+            ],
+        )
 
     def __eq__(self, other):
         ss = self.parent().one() * self
@@ -202,7 +203,7 @@ def _double_schub_parser(passed):
     fdict = {}
     vardict = {}
     fdict[passed._sc_rep] = passed._element_constructor_
-    if passed._quantum:        
+    if passed._quantum:
         QSRing = bork.FastSchubertPolynomialRing(
             passed._base_polynomial_ring.base_ring(),
             len(passed._base_polynomial_ring.gens()),
@@ -211,31 +212,31 @@ def _double_schub_parser(passed):
             code_display=passed._ascode,
             q_varname=passed._q_varname,
         )
-        fdict[QSRing._sc_rep] = QSRing._element_constructor_        
+        fdict[QSRing._sc_rep] = QSRing._element_constructor_
     SRing = bork.FastSchubertPolynomialRing(
-            passed._base_polynomial_ring.base_ring().base_ring(),
-            len(passed._base_polynomial_ring.gens()),
-            passed._base_varname,
-            is_quantum=False,
-            code_display=passed._ascode,
-        ) 
+        passed._base_polynomial_ring.base_ring().base_ring(),
+        len(passed._base_polynomial_ring.gens()),
+        passed._base_varname,
+        is_quantum=False,
+        code_display=passed._ascode,
+    )
     DRing = FastDoubleSchubertPolynomialRing(
-            passed._base_polynomial_ring.base_ring().base_ring(),
-            len(passed._base_polynomial_ring.gens()),
-            passed._base_varname,
-            coeff_variable_names=tuple(passed._varlist),
-        )
+        passed._base_polynomial_ring.base_ring().base_ring(),
+        len(passed._base_polynomial_ring.gens()),
+        passed._base_varname,
+        coeff_variable_names=tuple(passed._varlist),
+    )
     fdict[DRing._sc_rep] = DRing._element_constructor_
-    fdict[SRing._sc_rep] = SRing._element_constructor_        
+    fdict[SRing._sc_rep] = SRing._element_constructor_
     for g in passed._base_polynomial_ring.gens():
-            vardict[str(g)] = g
+        vardict[str(g)] = g
     return Parser(make_function=fdict, make_var=vardict)
 
 
 class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
     Element = FastDoubleSchubertPolynomial_class
 
-    #def inject_variables:
+    # def inject_variables:
 
     def parser(self):
         if self._parser is None:
@@ -266,21 +267,22 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
         if isinstance(coeff_variable_names, tuple):
             self._mixed = True
             self._varlist = [*coeff_variable_names]
-            self._coeff_polynomial_rings = {
-                name: PolynomialRing(R if not quantum else QR, num_vars, name)
-                for name in self._varlist
-            }
+            self._coeff_polynomial_rings = {name: PolynomialRing(R if not quantum else QR, num_vars, name) for name in self._varlist}
 
             self._coeff_polynomial_ring = R if not quantum else QR
             for name, CR in self._coeff_polynomial_rings.items():
                 self._coeff_polynomial_ring = PolynomialRing(
-                    self._coeff_polynomial_ring, num_vars, name
+                    self._coeff_polynomial_ring,
+                    num_vars,
+                    name,
                 )
             self._coeff_polynomial_ring = FlatteningMorphism(self._coeff_polynomial_ring).codomain()
         else:
             self._varlist = [coeff_variable_names]
             self._coeff_polynomial_ring = PolynomialRing(
-                R if not quantum else QR, num_vars, coeff_variable_names
+                R if not quantum else QR,
+                num_vars,
+                coeff_variable_names,
             )
             self._coeff_polynomial_rings = {}
             self._coeff_polynomial_rings[coeff_variable_names] = self._coeff_polynomial_ring
@@ -293,15 +295,13 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             self._ascode = True
 
         self._base_polynomial_ring = PolynomialRing(
-            self._coeff_polynomial_ring, num_vars, base_variable_name
+            self._coeff_polynomial_ring,
+            num_vars,
+            base_variable_name,
         )
 
         self._index_wrapper = cartesian_product([index_set, self._varlist])
-        cat = (
-            GradedAlgebrasWithBasis(self._coeff_polynomial_ring).Commutative()
-            if quantum
-            else GradedBialgebrasWithBasis(self._coeff_polynomial_ring).Commutative()
-        )
+        cat = GradedAlgebrasWithBasis(self._coeff_polynomial_ring).Commutative() if quantum else GradedBialgebrasWithBasis(self._coeff_polynomial_ring).Commutative()
 
         self._sc_rep = f"{'Q' if quantum else ''}DS{base_variable_name}"
 
@@ -334,12 +334,7 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
 
         if isinstance(x, str):
             return self.parser().parse(x)
-        elif (
-            isinstance(x, list)
-            or isinstance(x, tuple)
-            or isinstance(x, Permutation)
-            or isinstance(x, Composition)
-        ):
+        if isinstance(x, list) or isinstance(x, tuple) or isinstance(x, Permutation) or isinstance(x, Composition):
             # checking the input to avoid symmetrica crashing Sage, see trac 12924
             if x in self._index_wrapper:
                 elem = self._from_dict({self._index_wrapper((x[0], x[1])): self.base_ring().one()})
@@ -350,31 +345,19 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                             (
                                 _coerce_index(x, self._ascode, self._ascode),
                                 self._varlist[0],
-                            )
-                        ): self.base_ring().one()
-                    }
+                            ),
+                        ): self.base_ring().one(),
+                    },
                 )
         elif isinstance(x, FastDoubleSchubertPolynomial):
-            if (
-                x.base_varname == self._base_varname
-                and (self._quantum == x.parent()._quantum)
-                and (not self._quantum or x.q_varname == self._q_varname)
-            ):
+            if x.base_varname == self._base_varname and (self._quantum == x.parent()._quantum) and (not self._quantum or x.q_varname == self._q_varname):
                 elem = self._from_dict(
-                    {
-                        (_coerce_index(k[0], x.parent()._ascode, self._ascode), k[1]): v
-                        for k, v in x.monomial_coefficients().items()
-                    }
+                    {(_coerce_index(k[0], x.parent()._ascode, self._ascode), k[1]): v for k, v in x.monomial_coefficients().items()},
                 )
             else:
                 return self(x.expand())
         elif isinstance(x, bork.FastSchubertPolynomial):
-            if (
-                x.base_varname == self._base_varname
-                and x.q_varname == self._q_varname
-                and (self._quantum == x.parent()._quantum)
-                and (not self._quantum or x.q_varname == self._q_varname)
-            ):
+            if x.base_varname == self._base_varname and x.q_varname == self._q_varname and (self._quantum == x.parent()._quantum) and (not self._quantum or x.q_varname == self._q_varname):
                 elem_dict = {}
 
                 for k, v in x.monomial_coefficients().items():
@@ -386,7 +369,7 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                             [
                                 0
                                 for i in range(
-                                    len(self._coeff_polynomial_rings[self._varlist[0]].gens())
+                                    len(self._coeff_polynomial_rings[self._varlist[0]].gens()),
                                 )
                             ],
                             self._q_ring.gens(),
@@ -399,18 +382,15 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                             [
                                 0
                                 for i in range(
-                                    len(self._coeff_polynomial_rings[self._varlist[0]].gens())
+                                    len(self._coeff_polynomial_rings[self._varlist[0]].gens()),
                                 )
                             ],
                         )
                     for k0, c0 in res.items():
-                        elem_dict[(_coerce_index(k0, False, self._ascode), self._varlist[0])] = (
-                            elem_dict.get(
-                                (_coerce_index(k0, False, self._ascode), self._varlist[0]),
-                                self._coeff_polynomial_ring.zero(),
-                            )
-                            + self._coeff_polynomial_ring(c0)
-                        )
+                        elem_dict[(_coerce_index(k0, False, self._ascode), self._varlist[0])] = elem_dict.get(
+                            (_coerce_index(k0, False, self._ascode), self._varlist[0]),
+                            self._coeff_polynomial_ring.zero(),
+                        ) + self._coeff_polynomial_ring(c0)
                 elem = self._from_dict(elem_dict)
             else:
                 elem = self(x.expand())
@@ -425,10 +405,7 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                     {(1, 2): 1},
                     val,
                     [syme.Symbol(str(g)) for g in self._base_polynomial_ring.gens()],
-                    [
-                        syme.Symbol(str(g))
-                        for g in self._coeff_polynomial_rings[self._varlist[0]].gens()
-                    ],
+                    [syme.Symbol(str(g)) for g in self._coeff_polynomial_rings[self._varlist[0]].gens()],
                     [syme.Symbol(str(g)) for g in self._q_ring.gens()],
                 )
             else:
@@ -436,10 +413,7 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                     {(1, 2): 1},
                     val,
                     [syme.Symbol(str(g)) for g in self._base_polynomial_ring.gens()],
-                    [
-                        syme.Symbol(str(g))
-                        for g in self._coeff_polynomial_rings[self._varlist[0]].gens()
-                    ],
+                    [syme.Symbol(str(g)) for g in self._coeff_polynomial_rings[self._varlist[0]].gens()],
                 )
             elem = self._from_dict(
                 {
@@ -448,7 +422,7 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                         self._varlist[0],
                     ): self._coeff_polynomial_ring(str(v))
                     for k, v in result.items()
-                }
+                },
             )
         else:
             raise TypeError
@@ -458,21 +432,15 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
     def some_elements(self):
         return [
             self.one(),
-            self(_coerce_index([1], False, self._ascode))
-            + 2 * self(_coerce_index([2, 1], False, self._ascode)),
-            self(_coerce_index([4, 2, 1, 3], False, self._ascode))
-            - self(_coerce_index([3, 2, 1], False, self._ascode)),
+            self(_coerce_index([1], False, self._ascode)) + 2 * self(_coerce_index([2, 1], False, self._ascode)),
+            self(_coerce_index([4, 2, 1, 3], False, self._ascode)) - self(_coerce_index([3, 2, 1], False, self._ascode)),
         ]
 
     def product_on_basis(self, left, right):
         le = tuple(left[0])
         ri = tuple(right[0])
-        var_y = [
-            self._coeff_polynomial_ring(g) for g in self._coeff_polynomial_rings[left[1]].gens()
-        ]
-        var_z = [
-            self._coeff_polynomial_ring(g) for g in self._coeff_polynomial_rings[right[1]].gens()
-        ]
+        var_y = [self._coeff_polynomial_ring(g) for g in self._coeff_polynomial_rings[left[1]].gens()]
+        var_z = [self._coeff_polynomial_ring(g) for g in self._coeff_polynomial_rings[right[1]].gens()]
         if self._quantum:
             result = qyz.schubmult_db(
                 {tuple(_coerce_index(le, self._ascode, False)): 1},
@@ -490,11 +458,7 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             )
         result = {k: v for k, v in result.items() if v != 0}
         return sum(
-            [
-                self._coeff_polynomial_ring(v)
-                * self((_coerce_index(k, False, self._ascode), left[1]))
-                for k, v in result.items()
-            ]
+            [self._coeff_polynomial_ring(v) * self((_coerce_index(k, False, self._ascode), left[1])) for k, v in result.items()],
         )
 
     def _coerce_map_from_(self, S):
@@ -559,24 +523,24 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                     continue
                 firstperm = Permutation(permtrim(list(downperm[0:N])))
                 secondperm = Permutation(
-                    permtrim([downperm[i] - N for i in range(N, len(downperm))])
+                    permtrim([downperm[i] - N for i in range(N, len(downperm))]),
                 )
                 val = TR(val).subs(subs_dict_coprod)
                 total_sum += self._coeff_polynomial_ring(val) * self(
-                    (_coerce_index(firstperm, False, self._ascode), indm[1])
+                    (_coerce_index(firstperm, False, self._ascode), indm[1]),
                 ).tensor(
                     self(
                         (
                             _coerce_index(secondperm, False, self._ascode),
                             self._varlist[0],
-                        )
-                    )
+                        ),
+                    ),
                 )
         return total_sum
 
     def _repr_(self):
         return (
-            f"Ring of {'quantum' if self._quantum else ''} double Schubert polynomials in {self._base_varname}{',' + self._q_varname if self._quantum else ''} with {len(self._base_polynomial_ring.gens())} variables with"
+            f"Ring of {'quantum' if self._quantum else ''} double Schubert polynomials in {self._base_varname}{',' + self._q_varname if self._quantum else ''} with {len(self._base_polynomial_ring.gens())} variables with"  # noqa: E501
             f" coefficient variables {','.join(self._varlist)} over the ring {self._coeff_polynomial_ring.base_ring()} indexed by {'the Lehmer code' if self._ascode else 'permutations'}"
         )
 

schubmult/sage_integration/_fast_schubert_polynomial_ring.py

@@ -1,32 +1,31 @@
+from functools import cache
+
+# from sage.misc.parser import Parser
+import symengine as syme
 from sage.all import *  # noqa: F403
-from sage.categories.graded_bialgebras_with_basis import GradedBialgebrasWithBasis
 from sage.categories.graded_algebras_with_basis import GradedAlgebrasWithBasis
-from sage.combinat.free_module import CombinatorialFreeModule
-
-from sage.combinat.permutation import Permutations, Permutation, from_lehmer_code
+from sage.categories.graded_bialgebras_with_basis import GradedBialgebrasWithBasis
 from sage.combinat.composition import (
-    Compositions,
     Composition,
+    Compositions,
 )
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.combinat.permutation import Permutation, Permutations, from_lehmer_code
 from sage.misc.cachefunc import cached_method
-from sage.rings.polynomial.multi_polynomial_ring import MPolynomialRing_base
 from sage.rings.polynomial.multi_polynomial import MPolynomial
+from sage.rings.polynomial.multi_polynomial_ring import MPolynomialRing_base
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
-from ._indexing import _coerce_index
+from sympy import sympify
 
-from schubmult.perm_lib import permtrim
+import schubmult.sage_integration._fast_double_schubert_polynomial_ring as bork
+import schubmult.schubmult_double as yz
+import schubmult.schubmult_py as py
 import schubmult.schubmult_q as sq
 import schubmult.schubmult_q_double as qyz
-import schubmult.schubmult_py as py
-import schubmult.schubmult_double as yz
-
+from schubmult.perm_lib import permtrim
 
-from sympy import sympify
+from ._indexing import _coerce_index
 
-# from sage.misc.parser import Parser
-import symengine as syme
-import schubmult.sage_integration._fast_double_schubert_polynomial_ring as bork
-from functools import cache
 # FastQuantumDoubleSchubertPolynomialRing = bork.FastQuantumDoubleSchubertPolynomialRing
 
 
@@ -38,9 +37,10 @@ def FastSchubertPolynomialRing(
     code_display: bool = False,
     q_varname: str = "q",
     is_quantum: bool = False,
-    indices: tuple[int] = tuple([1]),
+    indices: tuple[int] = (1,),
 ):
-    """Wrapper function to return a double Schubert polynomial Ring
+    """
+    Wrapper function to return a double Schubert polynomial Ring
 
         Calls the _xbasis class to return a (quantum) Schubert
         polynomial ring with the indicated base ring, number of variables,
@@ -67,6 +67,7 @@ def FastSchubertPolynomialRing(
 
     Returns:
         FastSchubertPolynomialRing_xbasis: Element constructor of the ring
+
     """
     if is_quantum:
         QR = PolynomialRing(R, num_vars, q_varname)
@@ -91,7 +92,8 @@ def FastQuantumSchubertPolynomialRing(
     q_varname: str = "q",
     code_display: bool = False,
 ):
-    """Quantum Schubert ring generator
+    """
+    Quantum Schubert ring generator
 
     Wraps FastSchubertPolynomialRing(), omitting indices and setting
     is_quantum to True.
@@ -106,6 +108,7 @@ def FastQuantumSchubertPolynomialRing(
 
     Returns:
         FastSchubertPolynomialRing_xbasis: Element constructor of the ring
+
     """
     return FastSchubertPolynomialRing(
         R,
@@ -145,25 +148,24 @@ class FastSchubertPolynomial_class(CombinatorialFreeModule.Element):
                             [0 for i in range(100)],
                             self.parent()._q_ring.gens(),
                             v,
-                        )
+                        ),
                     )
                     for k, v in self.monomial_coefficients().items()
-                ]
-            )
-        else:
-            return sum(
-                [
-                    self.parent()._polynomial_ring(
-                        yz.schubmult(
-                            {(1, 2): v},
-                            tuple(_coerce_index(k, self.parent()._ascode, False)),
-                            self.parent()._polynomial_ring.gens(),
-                            [0 for i in range(100)],
-                        ).get((1, 2), 0)
-                    )
-                    for k, v in self.monomial_coefficients().items()
-                ]
+                ],
             )
+        return sum(
+            [
+                self.parent()._polynomial_ring(
+                    yz.schubmult(
+                        {(1, 2): v},
+                        tuple(_coerce_index(k, self.parent()._ascode, False)),
+                        self.parent()._polynomial_ring.gens(),
+                        [0 for i in range(100)],
+                    ).get((1, 2), 0),
+                )
+                for k, v in self.monomial_coefficients().items()
+            ],
+        )
 
 
 @cache
@@ -185,12 +187,12 @@ def _single_schub_parser(passed):
 
 class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
     Element = FastSchubertPolynomial_class
-    
+
     def parser(self):
         if self._parser is None:
             self._parser = _single_schub_parser(self)
         return self._parser
-        
+
 
     def __init__(
         self,
@@ -263,7 +265,7 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
     def _element_constructor_(self, x):
         if isinstance(x, str):
             return self.parser().parse(x)
-        elif (
+        if (
             isinstance(x, list)
             or isinstance(x, tuple)
             or isinstance(x, Composition)
@@ -271,7 +273,7 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
         ):
             # checking the input to avoid symmetrica crashing Sage, see trac 12924
             elem = self._from_dict(
-                {_coerce_index(x, self._ascode, self._ascode): self.base_ring().one()}
+                {_coerce_index(x, self._ascode, self._ascode): self.base_ring().one()},
             )
         elif isinstance(x, FastSchubertPolynomial):
             if (
@@ -283,7 +285,7 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                     {
                         _coerce_index(k, x.parent()._ascode, self._ascode): v
                         for k, v in x.monomial_coefficients().items()
-                    }
+                    },
                 )
             else:
                 return self(x.expand())
@@ -312,7 +314,7 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                     if self._quantum
                     else self.base_ring()(str(v))
                     for k, v in result.items()
-                }
+                },
             )
         else:
             raise TypeError(f"Could not convert {x=} to {self}")
@@ -337,18 +339,17 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                         tuple(_coerce_index(right, self._ascode, False)),
                         list(self._q_ring.gens()),
                     ).items()
-                ]
-            )
-        else:
-            return sum(
-                [
-                    self.base_ring()(v) * self(_coerce_index(k, False, self._ascode))
-                    for k, v in py.schubmult(
-                        {tuple(_coerce_index(left, self._ascode, False)): 1},
-                        tuple(_coerce_index(right, self._ascode, False)),
-                    ).items()
-                ]
+                ],
             )
+        return sum(
+            [
+                self.base_ring()(v) * self(_coerce_index(k, False, self._ascode))
+                for k, v in py.schubmult(
+                    {tuple(_coerce_index(left, self._ascode, False)): 1},
+                    tuple(_coerce_index(right, self._ascode, False)),
+                ).items()
+            ],
+        )
 
     def coproduct_on_basis(self, mperm):
         if self._quantum:
@@ -382,10 +383,10 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                     continue
                 firstperm = Permutation(permtrim(list(downperm[0:N])))
                 secondperm = Permutation(
-                    permtrim([downperm[i] - N for i in range(N, len(downperm))])
+                    permtrim([downperm[i] - N for i in range(N, len(downperm))]),
                 )
                 total_sum += self.base_ring()(val) * self(
-                    _coerce_index(firstperm, False, self._ascode)
+                    _coerce_index(firstperm, False, self._ascode),
                 ).tensor(self(_coerce_index(secondperm, False, self._ascode)))
         return total_sum